xbintsc 0.5.37 → 0.5.41

package/runtime/ext_gui/renderer_image.cpp

@@ -12,6 +12,7 @@
 #include "canvas.h"
 #include "image.h"
 #include "media.h"
+#include "perf.h"
 #include "svg.h"
 #include "webgl.h"
 
@@ -27,61 +28,98 @@ struct MediaTexture {
   int width = 0;
   int height = 0;
   uint64_t generation = ~0ull;
+  /** Staging transfer buffer reused by every upload into this texture. */
+  SDL_GPUTransferBuffer *staging = nullptr;
+  uint32_t staging_capacity = 0;
 };
 
 static std::unordered_map<uint64_t, MediaTexture> g_media_textures;
 
 /** One live `<canvas>` texture, keyed by the canvas id from `canvas.h`. It is
- * re-uploaded in place whenever the canvas bumps its `generation`. */
+ * re-uploaded in place whenever the canvas bumps its `generation`; only the
+ * canvas's dirty rectangle is copied. */
 static std::unordered_map<uint64_t, MediaTexture> g_canvas_textures;
 
-/** Upload RGBA8 `pixels` into `texture` through a staging buffer, submitting
- * its own command buffer. Because command buffers run in submission order and
- * this one is submitted before the frame that samples the texture, re-uploading
- * a texture that the previous frame drew is safe. */
-static bool uploadPixels(SDL_GPUDevice *device, SDL_GPUTexture *texture, int width, int height,
-                         const void *pixels, uint32_t bytes) {
+static void releaseStaging(SDL_GPUDevice *device, MediaTexture &entry) {
+  if (entry.staging != nullptr) SDL_ReleaseGPUTransferBuffer(device, entry.staging);
+  entry.staging = nullptr;
+  entry.staging_capacity = 0;
+}
+
+/** Upload the device-space rectangle `(x, y, w, h)` of an RGBA8 image into
+ * `texture`, through `entry`'s reused staging buffer. Because command buffers
+ * run in submission order and this copy is submitted before the frame that
+ * samples the texture, re-uploading a texture the previous frame drew is
+ * safe. With a batch the copy joins the frame's upload command buffer. */
+static bool uploadPixels(SDL_GPUDevice *device, MediaTexture &entry, const void *pixels,
+                         int image_width, int x, int y, int w, int h,
+                         XtGuiUploadBatch *batch) {
+  if (entry.texture == nullptr || w <= 0 || h <= 0) return false;
+  const uint32_t bytes = (uint32_t)w * (uint32_t)h * 4u;
   if (bytes == 0) return false;
-  SDL_GPUTransferBufferCreateInfo transfer_info;
-  memset(&transfer_info, 0, sizeof(transfer_info));
-  transfer_info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
-  transfer_info.size = bytes;
-  SDL_GPUTransferBuffer *transfer = SDL_CreateGPUTransferBuffer(device, &transfer_info);
-  if (transfer == nullptr) return false;
-  void *mapped = SDL_MapGPUTransferBuffer(device, transfer, false);
-  std::memcpy(mapped, pixels, bytes);
-  SDL_UnmapGPUTransferBuffer(device, transfer);
-
-  SDL_GPUCommandBuffer *cmd = SDL_AcquireGPUCommandBuffer(device);
-  if (cmd == nullptr) {
-    SDL_ReleaseGPUTransferBuffer(device, transfer);
-    return false;
+  if (entry.staging == nullptr || entry.staging_capacity < bytes) {
+    releaseStaging(device, entry);
+    SDL_GPUTransferBufferCreateInfo transfer_info;
+    memset(&transfer_info, 0, sizeof(transfer_info));
+    transfer_info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+    transfer_info.size = bytes;
+    entry.staging = SDL_CreateGPUTransferBuffer(device, &transfer_info);
+    entry.staging_capacity = entry.staging != nullptr ? bytes : 0;
+    if (entry.staging == nullptr) return false;
+  }
+  /* `cycle` rotates SDL's internal allocation while the previous frame's copy
+   * may still be in flight. */
+  void *mapped = SDL_MapGPUTransferBuffer(device, entry.staging, true);
+  if (mapped == nullptr) return false;
+  const unsigned char *source = (const unsigned char *)pixels;
+  unsigned char *destination = (unsigned char *)mapped;
+  for (int row = 0; row < h; row++) {
+    memcpy(destination + (size_t)row * (size_t)w * 4,
+           source + ((size_t)(y + row) * (size_t)image_width + (size_t)x) * 4,
+           (size_t)w * 4);
   }
-  SDL_GPUTextureTransferInfo source;
-  memset(&source, 0, sizeof(source));
-  source.transfer_buffer = transfer;
-  source.offset = 0;
-  source.pixels_per_row = (Uint32)width;
-  source.rows_per_layer = (Uint32)height;
-  SDL_GPUTextureRegion destination;
-  memset(&destination, 0, sizeof(destination));
-  destination.texture = texture;
-  destination.mip_level = 0;
-  destination.layer = 0;
-  destination.w = (Uint32)width;
-  destination.h = (Uint32)height;
-  destination.d = 1;
+  SDL_UnmapGPUTransferBuffer(device, entry.staging);
+
+  SDL_GPUCommandBuffer *cmd = xtgui::renderer_detail::uploadCommand(device, batch);
+  if (cmd == nullptr) return false;
+  SDL_GPUTextureTransferInfo source_info;
+  memset(&source_info, 0, sizeof(source_info));
+  source_info.transfer_buffer = entry.staging;
+  source_info.offset = 0;
+  source_info.pixels_per_row = (Uint32)w;
+  source_info.rows_per_layer = (Uint32)h;
+  SDL_GPUTextureRegion destination_region;
+  memset(&destination_region, 0, sizeof(destination_region));
+  destination_region.texture = entry.texture;
+  destination_region.x = (Uint32)x;
+  destination_region.y = (Uint32)y;
+  destination_region.mip_level = 0;
+  destination_region.layer = 0;
+  destination_region.w = (Uint32)w;
+  destination_region.h = (Uint32)h;
+  destination_region.d = 1;
   SDL_GPUCopyPass *copy = SDL_BeginGPUCopyPass(cmd);
-  SDL_UploadToGPUTexture(copy, &source, &destination, false);
+  SDL_UploadToGPUTexture(copy, &source_info, &destination_region, false);
   SDL_EndGPUCopyPass(copy);
-  SDL_SubmitGPUCommandBuffer(cmd);
-  SDL_ReleaseGPUTransferBuffer(device, transfer);
+  xtgui::renderer_detail::uploadDone(cmd, batch);
   return true;
 }
 
+/** One-shot full-texture upload (image/SVG decode), used when there is no
+ * long-lived texture entry to keep a staging buffer on. */
+static bool uploadWholeTexture(SDL_GPUDevice *device, SDL_GPUTexture *texture, int width,
+                               int height, const void *pixels, XtGuiUploadBatch *batch) {
+  MediaTexture temporary;
+  temporary.texture = texture;
+  const bool ok = uploadPixels(device, temporary, pixels, width, 0, 0, width, height, batch);
+  releaseStaging(device, temporary);
+  return ok;
+}
+
 /** Ensure the texture for `media_id` exists and holds the decoder's newest
  * frame. Returns `nullptr` before the first frame is decoded. */
-static SDL_GPUTexture *ensureMediaTexture(SDL_GPUDevice *device, uint64_t media_id) {
+static SDL_GPUTexture *ensureMediaTexture(SDL_GPUDevice *device, uint64_t media_id,
+                                          XtGuiUploadBatch *batch) {
   xtgui::MediaPlayer *player = xtgui::xt_media_by_id(media_id);
   if (player == nullptr) return nullptr;
   const xtgui::Image *image = player->frame();
@@ -106,8 +144,8 @@ static SDL_GPUTexture *ensureMediaTexture(SDL_GPUDevice *device, uint64_t media_
     if (entry.texture == nullptr) return nullptr;
   }
   if (entry.generation != player->frame_generation()) {
-    if (uploadPixels(device, entry.texture, entry.width, entry.height, image->pixels.data(),
-                     (uint32_t)image->pixels.size())) {
+    if (uploadPixels(device, entry, image->pixels.data(), image->width, 0, 0, entry.width,
+                     entry.height, batch)) {
       entry.generation = player->frame_generation();
     }
   }
@@ -117,7 +155,8 @@ static SDL_GPUTexture *ensureMediaTexture(SDL_GPUDevice *device, uint64_t media_
 /** Ensure the texture for `canvas_id` exists and holds the canvas's newest
  * pixels. A WebGL canvas already owns its colour target, so it is returned
  * directly and nothing is copied through the CPU. */
-static SDL_GPUTexture *ensureCanvasTexture(SDL_GPUDevice *device, uint64_t canvas_id) {
+static SDL_GPUTexture *ensureCanvasTexture(SDL_GPUDevice *device, uint64_t canvas_id,
+                                          XtGuiUploadBatch *batch) {
   if (xtgui::WebGLContext *webgl = xtgui::xt_webgl_by_id(canvas_id)) {
     return webgl->color_texture();
   }
@@ -144,11 +183,24 @@ static SDL_GPUTexture *ensureCanvasTexture(SDL_GPUDevice *device, uint64_t canva
     entry.generation = ~0ull;
     if (entry.texture == nullptr) return nullptr;
   }
-  if (entry.generation != canvas->generation()) {
-    if (uploadPixels(device, entry.texture, entry.width, entry.height, image.pixels.data(),
-                     (uint32_t)image.pixels.size())) {
-      entry.generation = canvas->generation();
-    }
+  if (entry.generation == canvas->generation()) return entry.texture;
+  const xtgui::Canvas2D::CanvasDirtyRect &dirty = canvas->pending_dirty();
+  /* A draw that changed no pixel (off canvas, zero coverage) must not pay for
+   * an upload: remember the generation and skip it. */
+  if (dirty.empty()) {
+    entry.generation = canvas->generation();
+    return entry.texture;
+  }
+  /* Capture the rectangle before `clear_dirty()` resets it. */
+  const int dirty_w = dirty.x1 - dirty.x0;
+  const int dirty_h = dirty.y1 - dirty.y0;
+  if (uploadPixels(device, entry, image.pixels.data(), image.width, dirty.x0, dirty.y0, dirty_w,
+                   dirty_h, batch)) {
+    entry.generation = canvas->generation();
+    canvas->clear_dirty();
+    xtgui::g_perf_frame.canvasUploads += 1;
+    xtgui::g_perf_frame.canvasUploadBytes +=
+        (uint64_t)dirty_w * (uint64_t)dirty_h * 4u;
   }
   return entry.texture;
 }
@@ -235,7 +287,8 @@ SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *
 
 /** Create an RGBA texture holding `image` and upload its pixels. Returns null
  * (after reporting the SDL error) when either step fails. */
-SDL_GPUTexture *createImageTexture(SDL_GPUDevice *device, const xtgui::Image &image) {
+SDL_GPUTexture *createImageTexture(SDL_GPUDevice *device, const xtgui::Image &image,
+                                   XtGuiUploadBatch *batch) {
   SDL_GPUTextureCreateInfo info;
   memset(&info, 0, sizeof(info));
   info.type = SDL_GPU_TEXTURETYPE_2D;
@@ -251,8 +304,7 @@ SDL_GPUTexture *createImageTexture(SDL_GPUDevice *device, const xtgui::Image &im
     fprintf(stderr, "xt_gui: image texture creation failed: %s\n", SDL_GetError());
     return nullptr;
   }
-  uint32_t bytes = (uint32_t)(image.pixels.size());
-  if (!uploadPixels(device, texture, image.width, image.height, image.pixels.data(), bytes)) {
+  if (!uploadWholeTexture(device, texture, image.width, image.height, image.pixels.data(), batch)) {
     SDL_ReleaseGPUTexture(device, texture);
     return nullptr;
   }
@@ -263,7 +315,7 @@ SDL_GPUTexture *createImageTexture(SDL_GPUDevice *device, const xtgui::Image &im
  * rasterised at the drawn pixel size and cached by that size; bitmaps decode at
  * their intrinsic size and are cached by path. */
 SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src, int pixel_width,
-                                   int pixel_height) {
+                                   int pixel_height, XtGuiUploadBatch *batch) {
   bool vector_source = xtgui::xt_image_is_vector(src);
   std::string key =
       vector_source ? src + "@" + std::to_string(pixel_width) + "x" + std::to_string(pixel_height)
@@ -278,7 +330,7 @@ SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src
     return nullptr;
   }
 
-  SDL_GPUTexture *texture = createImageTexture(device, *image);
+  SDL_GPUTexture *texture = createImageTexture(device, *image, batch);
   g_image_textures.emplace(key, texture);
   return texture;
 }
@@ -287,7 +339,8 @@ SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src
  * size and upload it. The markup is the cache key: a static document therefore
  * rasterises once per drawn size, and an edited one gets a fresh texture. */
 SDL_GPUTexture *ensureInlineSvgTexture(SDL_GPUDevice *device, const std::string &markup,
-                                       int pixel_width, int pixel_height) {
+                                       int pixel_width, int pixel_height,
+                                       XtGuiUploadBatch *batch) {
   std::string key = "inline-svg@" + std::to_string(pixel_width) + "x" +
                     std::to_string(pixel_height) + ":" + markup;
   auto found = g_image_textures.find(key);
@@ -300,7 +353,7 @@ SDL_GPUTexture *ensureInlineSvgTexture(SDL_GPUDevice *device, const std::string
     return nullptr;
   }
 
-  SDL_GPUTexture *texture = createImageTexture(device, image);
+  SDL_GPUTexture *texture = createImageTexture(device, image, batch);
   g_image_textures.emplace(key, texture);
   return texture;
 }
@@ -309,7 +362,7 @@ SDL_GPUTexture *ensureInlineSvgTexture(SDL_GPUDevice *device, const std::string
 }  // namespace xtgui
 
 void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
-                         const xtgui::DisplayList &list, float scale) {
+                         const xtgui::DisplayList &list, float scale, XtGuiUploadBatch *batch) {
   using namespace xtgui::renderer_detail;
   geometry->op_counts.assign(list.images.size(), 0);
   geometry->op_textures.assign(list.images.size(), nullptr);
@@ -318,7 +371,8 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
     return;
   }
   if (scale <= 0.0f) scale = 1.0f;
-  std::vector<TextVertex> verts;
+  std::vector<TextVertex> &verts = g_image_staging;
+  verts.clear();
   verts.reserve(list.images.size() * 6);
   GlyphEntry full;
   full.u0 = 0.0f;
@@ -337,13 +391,13 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
     if (pixel_height < 1) pixel_height = 1;
     SDL_GPUTexture *texture = nullptr;
     if (image.canvas_id != 0) {
-      texture = ensureCanvasTexture(device, image.canvas_id);
+      texture = ensureCanvasTexture(device, image.canvas_id, batch);
     } else if (image.media_id != 0) {
-      texture = ensureMediaTexture(device, image.media_id);
+      texture = ensureMediaTexture(device, image.media_id, batch);
     } else if (!image.svg.empty()) {
-      texture = ensureInlineSvgTexture(device, image.svg, pixel_width, pixel_height);
+      texture = ensureInlineSvgTexture(device, image.svg, pixel_width, pixel_height, batch);
     } else {
-      texture = ensureImageTexture(device, image.src, pixel_width, pixel_height);
+      texture = ensureImageTexture(device, image.src, pixel_width, pixel_height, batch);
     }
     if (texture == nullptr) continue;
     uint32_t count = pushGlyph(verts, image.x, image.y, image.width, image.height, full,
@@ -351,7 +405,7 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
     geometry->op_counts[op.index] = count;
     geometry->op_textures[op.index] = texture;
   }
-  uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(TextVertex));
+  uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(TextVertex), batch);
 }
 
 void xt_gui_image_textures_destroy(SDL_GPUDevice *device) {
@@ -362,17 +416,25 @@ void xt_gui_image_textures_destroy(SDL_GPUDevice *device) {
   g_image_textures.clear();
   for (auto &entry : g_media_textures) {
     if (entry.second.texture != nullptr) SDL_ReleaseGPUTexture(device, entry.second.texture);
+    releaseStaging(device, entry.second);
   }
   g_media_textures.clear();
   for (auto &entry : g_canvas_textures) {
     if (entry.second.texture != nullptr) SDL_ReleaseGPUTexture(device, entry.second.texture);
+    releaseStaging(device, entry.second);
   }
   g_canvas_textures.clear();
 }
 
-void xt_gui_media_upload_frames(SDL_GPUDevice *device) {
+bool xt_gui_media_upload_frames(SDL_GPUDevice *device, XtGuiUploadBatch *batch) {
   using namespace xtgui::renderer_detail;
-  for (auto &entry : g_media_textures) ensureMediaTexture(device, entry.first);
+  bool uploaded = false;
+  for (auto &entry : g_media_textures) {
+    const uint64_t before = entry.second.generation;
+    ensureMediaTexture(device, entry.first, batch);
+    uploaded = uploaded || entry.second.generation != before;
+  }
+  return uploaded;
 }
 
 void xt_gui_media_texture_release(SDL_GPUDevice *device, uint64_t media_id) {
@@ -380,12 +442,19 @@ void xt_gui_media_texture_release(SDL_GPUDevice *device, uint64_t media_id) {
   auto it = g_media_textures.find(media_id);
   if (it == g_media_textures.end()) return;
   if (it->second.texture != nullptr) SDL_ReleaseGPUTexture(device, it->second.texture);
+  releaseStaging(device, it->second);
   g_media_textures.erase(it);
 }
 
-void xt_gui_canvas_upload_frames(SDL_GPUDevice *device) {
+bool xt_gui_canvas_upload_frames(SDL_GPUDevice *device, XtGuiUploadBatch *batch) {
   using namespace xtgui::renderer_detail;
-  for (auto &entry : g_canvas_textures) ensureCanvasTexture(device, entry.first);
+  bool uploaded = false;
+  for (auto &entry : g_canvas_textures) {
+    const uint64_t before = xtgui::g_perf_frame.canvasUploads;
+    ensureCanvasTexture(device, entry.first, batch);
+    uploaded = uploaded || xtgui::g_perf_frame.canvasUploads != before;
+  }
+  return uploaded;
 }
 
 void xt_gui_canvas_texture_release(SDL_GPUDevice *device, uint64_t canvas_id) {
@@ -393,5 +462,6 @@ void xt_gui_canvas_texture_release(SDL_GPUDevice *device, uint64_t canvas_id) {
   auto it = g_canvas_textures.find(canvas_id);
   if (it == g_canvas_textures.end()) return;
   if (it->second.texture != nullptr) SDL_ReleaseGPUTexture(device, it->second.texture);
+  releaseStaging(device, it->second);
   g_canvas_textures.erase(it);
 }

package/runtime/ext_gui/renderer_internal.h

@@ -79,6 +79,18 @@ extern bool g_atlas_full_logged;
 
 /* -- geometry helpers ----------------------------------------------------- */
 
+/** Reused vertex staging arrays (one frame at a time, cleared on each upload).
+ * Keeping their capacity avoids reallocating a few megabytes per repaint. */
+extern std::vector<Vertex> g_shape_staging;
+extern std::vector<TextVertex> g_text_staging;
+extern std::vector<TextVertex> g_image_staging;
+
+/** The command buffer an upload records into: the frame's batch when given,
+ * otherwise a freshly acquired one that `uploadDone` submits. */
+SDL_GPUCommandBuffer *uploadCommand(SDL_GPUDevice *device, XtGuiUploadBatch *batch);
+/** Submit a command buffer acquired for a one-off upload (`batch == nullptr`). */
+void uploadDone(SDL_GPUCommandBuffer *cmd, XtGuiUploadBatch *batch);
+
 /** Push one rounded rectangle, clipped by the op's `clip-path` polygons (if
  * any). Returns the number of vertices appended. */
 uint32_t pushShape(std::vector<Vertex> &verts, const xtgui::PaintRect &rect,
@@ -95,14 +107,14 @@ uint32_t pushQuad(std::vector<TextVertex> &verts, const float corners_x[4],
                   const xtgui::Color &color, const xtgui::Matrix2D &transform,
                   const xtgui::PaintClip &clip, const xtgui::DisplayList &list);
 void uploadVertices(SDL_GPUDevice *device, XtGuiGeometry *geometry, const void *data,
-                    uint32_t count, uint32_t stride);
+                    uint32_t count, uint32_t stride, XtGuiUploadBatch *batch);
 
 /* -- text ----------------------------------------------------------------- */
 
 bool ensureAtlasTexture(SDL_GPUDevice *device);
 void markAtlasDirty(int x, int y, int width, int height);
 bool ensureGlyph(SDL_GPUDevice *device, xtgui::Font *font, uint32_t glyph, GlyphEntry &out);
-void flushAtlas(SDL_GPUDevice *device);
+void flushAtlas(SDL_GPUDevice *device, XtGuiUploadBatch *batch);
 SDL_GPUGraphicsPipeline *createTextPipeline(SDL_GPUDevice *device, SDL_Window *reference);
 SDL_GPUSampler *createSampler(SDL_GPUDevice *device);
 
@@ -114,7 +126,7 @@ SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *
  * rasterised at that size, raster sources ignore it. The texture cache is keyed
  * by the resulting pixel size, so an SVG drawn at two sizes gets two textures. */
 SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src, int pixel_width,
-                                   int pixel_height);
+                                   int pixel_height, XtGuiUploadBatch *batch);
 
 }  // namespace renderer_detail
 }  // namespace xtgui

package/runtime/ext_gui/renderer_text.cpp

@@ -12,6 +12,8 @@
 
 #include "text.h"
 
+#include "perf.h"
+
 #include "renderer_shaders.h"
 
 namespace xtgui {
@@ -114,7 +116,7 @@ bool ensureGlyph(SDL_GPUDevice *device, xtgui::Font *font, uint32_t glyph, Glyph
   return true;
 }
 
-void flushAtlas(SDL_GPUDevice *device) {
+void flushAtlas(SDL_GPUDevice *device, XtGuiUploadBatch *batch) {
   if (!g_atlas_dirty || g_atlas_texture == nullptr) return;
   g_atlas_dirty = false;
   int x0 = g_atlas_dirty_x0;
@@ -141,7 +143,7 @@ void flushAtlas(SDL_GPUDevice *device) {
   }
   SDL_UnmapGPUTransferBuffer(device, transfer);
 
-  SDL_GPUCommandBuffer *cmd = SDL_AcquireGPUCommandBuffer(device);
+  SDL_GPUCommandBuffer *cmd = uploadCommand(device, batch);
   if (cmd == nullptr) {
     SDL_ReleaseGPUTransferBuffer(device, transfer);
     return;
@@ -166,7 +168,7 @@ void flushAtlas(SDL_GPUDevice *device) {
   SDL_GPUCopyPass *copy = SDL_BeginGPUCopyPass(cmd);
   SDL_UploadToGPUTexture(copy, &source, &destination, false);
   SDL_EndGPUCopyPass(copy);
-  SDL_SubmitGPUCommandBuffer(cmd);
+  uploadDone(cmd, batch);
   SDL_ReleaseGPUTransferBuffer(device, transfer);
 }
 
@@ -270,7 +272,7 @@ SDL_GPUSampler *createSampler(SDL_GPUDevice *device) {
 }  // namespace xtgui
 
 void xt_gui_text_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
-                        const xtgui::DisplayList &list, float scale) {
+                        const xtgui::DisplayList &list, float scale, XtGuiUploadBatch *batch) {
   using namespace xtgui::renderer_detail;
   if (!g_text_ok) {
     geometry->vertex_count = 0;
@@ -278,7 +280,8 @@ void xt_gui_text_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
   }
   if (scale <= 0.0f) scale = 1.0f;
 
-  std::vector<TextVertex> verts;
+  std::vector<TextVertex> &verts = g_text_staging;
+  verts.clear();
   geometry->op_counts.assign(list.texts.size(), 0);
   for (const xtgui::PaintOp &op : list.ops) {
     if (op.kind != xtgui::PaintKind::Text || op.index >= list.texts.size()) continue;
@@ -296,16 +299,25 @@ void xt_gui_text_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
     if (glyph_scale < kMinGlyphScale) glyph_scale = kMinGlyphScale;
     if (glyph_scale > kMaxGlyphScale) glyph_scale = kMaxGlyphScale;
 
-    std::vector<xtgui::ShapedGlyph> glyphs;
-    xtgui::xt_text_shape_run(run.text, logical, glyphs);
+    const xtgui::ShapedRun *shaped = xtgui::xt_text_shape_cached(run.text, logical);
+    if (shaped == nullptr) continue;
     float pen_x = run.x;
     uint32_t before = (uint32_t)verts.size();
-    for (const xtgui::ShapedGlyph &glyph : glyphs) {
+    /* The scaled face is a per-run decision (the size and matrix are constant
+     * for the run); resolving it per glyph used to build a 512-byte key and
+     * hash it for every character on a HiDPI display. */
+    xtgui::Font *scaled_input = nullptr;
+    xtgui::Font *scaled_output = nullptr;
+    for (const xtgui::ShapedGlyph &glyph : shaped->glyphs) {
       if (glyph.glyph != 0) {
         xtgui::Font *face = glyph.font != nullptr ? glyph.font : logical;
         if (glyph_scale != 1.0f) {
-          xtgui::Font *scaled = xtgui::xt_text_scale(face, run.font.pixel_size * glyph_scale);
-          if (scaled != nullptr) face = scaled;
+          if (face != scaled_input) {
+            xtgui::Font *scaled = xtgui::xt_text_scale(face, run.font.pixel_size * glyph_scale);
+            scaled_input = face;
+            scaled_output = scaled != nullptr ? scaled : face;
+          }
+          face = scaled_output;
         }
         GlyphEntry entry;
         if (ensureGlyph(device, face, glyph.glyph, entry)) {
@@ -323,6 +335,6 @@ void xt_gui_text_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
     }
     geometry->op_counts[op.index] = (uint32_t)verts.size() - before;
   }
-  uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(TextVertex));
-  flushAtlas(device);
+  uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(TextVertex), batch);
+  flushAtlas(device, batch);
 }

package/runtime/ext_gui/script.cpp

@@ -25,6 +25,14 @@ static std::unordered_map<std::string, xt_value> &script_registry() {
   return registry;
 }
 
+/** Deferred module id -> its exports object. A `<script src>`'s imports are
+ * evaluated on first use (after `loadHTML`) and then shared by every script
+ * that imports the same module. */
+static std::unordered_map<std::string, xt_value> &deferred_registry() {
+  static std::unordered_map<std::string, xt_value> registry;
+  return registry;
+}
+
 extern "C" xt_value xt_register_script(int32_t argc, xt_value *argv) {
   if (argc >= 2) {
     xt_value id_value = xt_to_string(xt_arg(argc, argv, 0));
@@ -42,6 +50,29 @@ extern "C" xt_value xt_register_script(int32_t argc, xt_value *argv) {
 
 void xt_gui_script_gc_scan(void) {
   for (const auto &entry : script_registry()) xt_gc_mark_value(entry.second);
+  for (const auto &entry : deferred_registry()) xt_gc_mark_value(entry.second);
+}
+
+/** `__xt_defer(id, init)`: evaluate `init` once and return its exports. The
+ * placeholder is published before the call so a cyclic import sees the same
+ * object instead of recursing. */
+extern "C" xt_value xt_gui_defer_module(int32_t argc, xt_value *argv) {
+  if (argc < 2) return XT_UNDEFINED;
+  xt_value id_value = xt_to_string(xt_arg(argc, argv, 0));
+  const char *id = xt_string_data(id_value);
+  if (id == nullptr) return XT_UNDEFINED;
+  std::unordered_map<std::string, xt_value> &registry = deferred_registry();
+  auto found = registry.find(std::string(id));
+  if (found != registry.end()) return found->second;
+  xt_gc_register_root_provider(xt_gui_script_gc_scan);
+  xt_value exports = xt_object_new();
+  registry[std::string(id)] = exports;
+  xt_value init = xt_arg(argc, argv, 1);
+  if (XT_IS_FUNCTION(init)) {
+    exports = xt_call_with_this(init, XT_UNDEFINED, 0, nullptr);
+    registry[std::string(id)] = exports;
+  }
+  return exports;
 }
 
 /** Collect `data-xt-id` markers from `<script>` elements, in document order. */