xbintsc 0.5.45 → 0.5.52

package/runtime/ext_gui/webgl_draw_setup.cpp

@@ -142,6 +142,42 @@ int type_size(int type) {
   }
 }
 
+/** Content hash of the vertex input state a pipeline bakes in.
+ *
+ * `WebGLDrawKey` carries `attribs_version_`/`framebuffer_version_`, which are
+ * *monotonic counters*: every VAO bind and every framebuffer switch bumps them.
+ * A page that binds several VAOs per frame (three.js does, once per geometry)
+ * therefore produced a new pipeline key for every draw on every frame, and the
+ * per-program pipeline cache never hit — measured at ~250
+ * `SDL_CreateGPUGraphicsPipeline` calls per frame, several milliseconds of the
+ * frame on its own, with a cache that grew by that many entries every frame.
+ * The pipeline only depends on the layout itself, so key it by the layout's
+ * content: the same layout stays cached across frames and is shared by every
+ * object that uses it. */
+uint64_t vertex_layout_hash(const std::vector<SDL_GPUVertexAttribute> &attributes,
+                            const std::vector<SDL_GPUVertexBufferDescription> &buffers) {
+  uint64_t hash = 1469598103934665603ull;
+  auto mix = [&hash](uint64_t value) {
+    hash ^= value;
+    hash *= 1099511628211ull;
+    hash ^= hash >> 29;
+  };
+  mix(attributes.size());
+  for (const SDL_GPUVertexAttribute &attribute : attributes) {
+    mix(attribute.location);
+    mix(attribute.buffer_slot);
+    mix((uint64_t)(uint32_t)attribute.format);
+    mix(attribute.offset);
+  }
+  mix(buffers.size());
+  for (const SDL_GPUVertexBufferDescription &buffer : buffers) {
+    mix(buffer.slot);
+    mix(buffer.pitch);
+    mix((uint64_t)(uint32_t)buffer.input_rate);
+  }
+  return hash;
+}
+
 }  // namespace
 
 void WebGLContext::draw_state_hash(uint64_t *first, uint64_t *second) const {
@@ -298,10 +334,15 @@ const WebGLDrawSetup *WebGLContext::prepare_draw(const WebGLDrawKey &key) {
   /* The pipeline depends on the vertex layout and fixed-function state, not on
    * which GPU buffer happens to hold the data (a buffer can be recreated after
    * a grow) nor on the element-buffer binding. Normalise those fields out so a
-   * dynamic buffer does not create a fresh pipeline. */
+   * dynamic buffer does not create a fresh pipeline. The monotonic version
+   * counters are replaced by the layout's content hash (and zero): they change
+   * on every VAO bind / framebuffer switch without changing the pipeline, so
+   * keying on them re-created every pipeline once per frame. */
   WebGLDrawKey pipeline_key = key;
   pipeline_key.gpu_version = 0;
   pipeline_key.element_buffer = 0;
+  pipeline_key.attribs_version = vertex_layout_hash(setup.attributes, setup.buffers);
+  pipeline_key.framebuffer_version = 0;
   auto cached = program_->pipeline_cache.find(pipeline_key);
   if (cached != program_->pipeline_cache.end()) {
     setup.pipeline = cached->second;

package/runtime/ext_gui/webgl_feature.cpp

@@ -0,0 +1,82 @@
+/*
+ * xbintsc GUI engine — `webgl` link feature implementation.
+ *
+ * This translation unit is the only core-side place that references the WebGL
+ * context and DOM bindings. It is pulled out of `gui.a` only when
+ * `webgl_bridge.c` (the feature's C registration object) is linked, and installs
+ * `XtWebglApi` for the rest of the engine. Without it the table is null, so a
+ * page that never asks for WebGL does not link any `webgl_*`/`dom_api_webgl*`
+ * member.
+ */
+
+#include "webgl_feature.h"
+
+#include "webgl_api.h"
+#include "dom_api_internal.h"
+
+namespace {
+
+void *get(XtGuiWindow *win, const void *node, bool webgl2) {
+  return xt_gui_webgl_get(win, static_cast<const xtgui::Node *>(node), webgl2);
+}
+
+void *find(XtGuiWindow *win, const void *node) {
+  return xt_gui_webgl_find(win, static_cast<const xtgui::Node *>(node));
+}
+
+void forget(XtGuiWindow *win, const void *node) {
+  xt_gui_webgl_forget(win, static_cast<const xtgui::Node *>(node));
+}
+
+void shutdown(XtGuiWindow *win) { xt_gui_webgl_shutdown(win); }
+
+bool submit_all() { return xt_gui_webgl_submit_all(); }
+
+void info(void *context, float *width, float *height, uint64_t *id) {
+  auto *webgl = static_cast<xtgui::WebGLContext *>(context);
+  *width = (float)webgl->width();
+  *height = (float)webgl->height();
+  *id = webgl->id();
+}
+
+void resize(void *context, int width, int height) {
+  static_cast<xtgui::WebGLContext *>(context)->resize(width, height);
+}
+
+bool read_pixels(void *context, int x, int y, int width, int height, unsigned char *out) {
+  return static_cast<xtgui::WebGLContext *>(context)->read_pixels(x, y, width, height, out);
+}
+
+xt_value handle(xt_value self, void *context) {
+  return domapi::webgl_context_handle(self, static_cast<xtgui::WebGLContext *>(context));
+}
+
+xt_value proto(bool webgl2) {
+  return webgl2 ? domapi::webgl2_proto() : domapi::webgl_proto();
+}
+
+xt_value object_proto(const char *kind) { return domapi::webgl_object_proto(kind); }
+
+void *color_texture(uint64_t id) {
+  xtgui::WebGLContext *context = xtgui::xt_webgl_by_id(id);
+  return context != nullptr ? context->color_texture() : nullptr;
+}
+
+const XtWebglApi kWebglApi = {
+    get,
+    find,
+    forget,
+    shutdown,
+    submit_all,
+    info,
+    resize,
+    read_pixels,
+    handle,
+    proto,
+    object_proto,
+    color_texture,
+};
+
+}  // namespace
+
+extern "C" void xt_webgl_feature_register(void) { xt_webgl_api_install(&kWebglApi); }

package/runtime/ext_gui/webgl_feature.h

@@ -0,0 +1,28 @@
+/*
+ * xbintsc GUI engine — WebGL context lifetime, implemented by the optional
+ * `webgl` feature.
+ *
+ * These functions are only referenced by `webgl_feature.cpp`, which installs
+ * them in `XtWebglApi`; no core translation unit calls them directly. The header
+ * is therefore only included by the feature's own translation units.
+ */
+#ifndef XT_GUI_WEBGL_FEATURE_H
+#define XT_GUI_WEBGL_FEATURE_H
+
+#include "gui_engine.h"
+#include "webgl.h"
+
+/** The WebGL context of a `<canvas>`, creating it on first use. `webgl2`
+ * selects the WebGL 2 API/prototype; a canvas keeps the first context kind it
+ * asked for. */
+xtgui::WebGLContext *xt_gui_webgl_get(XtGuiWindow *win, const xtgui::Node *node, bool webgl2);
+/** The existing WebGL context of `node`, or null (no side effects). */
+xtgui::WebGLContext *xt_gui_webgl_find(XtGuiWindow *win, const xtgui::Node *node);
+/** Drop a node's WebGL context (called when its handle is forgotten). */
+void xt_gui_webgl_forget(XtGuiWindow *win, const xtgui::Node *node);
+/** Release every WebGL context of `win`. */
+void xt_gui_webgl_shutdown(XtGuiWindow *win);
+/** Submit every live context's queued commands; true when any exists. */
+bool xt_gui_webgl_submit_all();
+
+#endif /* XT_GUI_WEBGL_FEATURE_H */

package/runtime/ext_gui/webgl_msl.cpp

@@ -6,10 +6,19 @@
  * share one GLSL front end: the Vulkan path hands the SPIR-V to SDL_GPU
  * directly, the Metal path cross-compiles it to MSL text that SDL_GPU's Metal
  * backend compiles at run time.
+ *
+ * Metal is the only SDL_GPU backend that consumes MSL, so `scripts/build-gui.ts`
+ * merges SPIRV-Cross into `gui.a` on macOS only; the rest of this file is a stub
+ * (the `#else` branch) so no caller needs an `#if`. Including the archive
+ * everywhere would instead add ~2.5 MiB of code no driver can ever ask for.
  */
 
 #include "webgl_msl.h"
 
+#if defined(__APPLE__)
+
+#include <cstdio>
+#include <cstdlib>
 #include <exception>
 
 #include <spirv_msl.hpp>
@@ -42,6 +51,13 @@ bool cross_compile_msl(const std::vector<uint32_t> &spirv, bool fragment,
     options.msl_version = spirv_cross::CompilerMSL::Options::make_msl_version(2, 0);
     compiler.set_msl_options(options);
     *source = compiler.compile();
+    /* The GLSL dump (`XT_WEBGL_DUMP_GLSL`) stops at the SPIR-V front end; this
+     * one shows what SPIRV-Cross handed the Metal backend, which is where a
+     * backend-only sampling difference (depth/comparison samplers) shows up. */
+    if (getenv("XT_WEBGL_DUMP_MSL") != nullptr) {
+      fprintf(stderr, "--- MSL %s ---\n%s\n---\n", fragment ? "fragment" : "vertex",
+              source->c_str());
+    }
     *entry = compiler.get_cleansed_entry_point_name(
         "main", fragment ? spv::ExecutionModelFragment : spv::ExecutionModelVertex);
     if (entry->empty()) {
@@ -64,3 +80,28 @@ bool cross_compile_msl(const std::vector<uint32_t> &spirv, bool fragment,
 }
 
 }  // namespace xtgui
+
+#else /* !__APPLE__ */
+
+namespace xtgui {
+
+/**
+ * Non-Metal builds carry no SPIRV-Cross, so there is nothing to translate with.
+ *
+ * No SDL_GPU backend outside Apple platforms reports MSL, so no driver can reach
+ * this; it exists so the callers keep one unconditional branch and a device that
+ * ever did advertise MSL fails with an actionable log instead of a wrong shader.
+ */
+bool cross_compile_msl(const std::vector<uint32_t> &spirv, bool fragment,
+                       std::string *source, std::string *entry, std::string *log) {
+  (void)spirv;
+  (void)fragment;
+  source->clear();
+  entry->clear();
+  *log = "this build has no MSL backend (SPIRV-Cross is macOS-only)";
+  return false;
+}
+
+}  // namespace xtgui
+
+#endif /* __APPLE__ */

package/runtime/ext_gui/webgl_msl.h

@@ -8,6 +8,12 @@
  * cross-compiles it to MSL while keeping the binding indices the rewriter
  * assigned — one std140 block at buffer 0 and stage-local samplers at
  * binding N, which is exactly the slot layout SDL_GPU's Metal backend binds.
+ *
+ * Only a macOS build links SPIRV-Cross (`scripts/build-gui.ts` skips the
+ * archive elsewhere); on every other platform the same function is a stub that
+ * reports the missing backend. No driver outside Apple platforms consumes MSL,
+ * so the stub is unreachable — keeping the declaration unconditional just means
+ * the callers need no `#if`.
  */
 #ifndef XT_GUI_WEBGL_MSL_H
 #define XT_GUI_WEBGL_MSL_H

package/runtime/ext_gui/webgl_shader.cpp

@@ -1,12 +1,9 @@
 /*
  * xbintsc GUI engine — WebGL shaders, programs, linking and uniforms.
  *
- * `compileShader` performs a standalone translation so `COMPILE_STATUS` and the
- * info log work before linking. `linkProgram` then translates both stages again
- * with one shared attribute/varying location map, compiles them with glslang
- * and reflects the std140 block out of the SPIR-V. The SDL_GPU shader then
- * takes whichever form the device accepts: the SPIR-V module itself on Vulkan,
- * or the same module cross-compiled to MSL by SPIRV-Cross on Metal.
+ * Translation/compilation goes through the optional `gpu` table (glslang);
+ * `linkProgram` shares attribute/varying locations between the stages and
+ * reflects the std140 block from the SPIR-V.
  */
 
 #include "webgl.h"
@@ -16,15 +13,13 @@
 #include <cstring>
 
 #include "gui_internal.h"
-#include "webgl_msl.h"
+#include "gpu_shader_api.h"
 #include "webgl_program_internal.h"
 
 namespace xtgui {
 namespace {
-
 using webgl_detail::gl_type_of;
 using webgl_detail::location_slots;
-
 /** Merge uniforms declared by both stages, in declaration order. */
 bool merge_uniforms(const GlslShaderInfo &vs, const GlslShaderInfo &fs,
                     std::vector<GlslUniformDecl> *out, std::string *error) {
@@ -80,17 +75,17 @@ struct StageCode {
   std::string text;
 };
 
-/**
- * Turn a compiled SPIR-V stage into the form the device consumes.
- *
- * Metal has no SPIR-V loader, so the module is cross-compiled to MSL; Vulkan
- * takes the SPIR-V directly. `code` points into `text` for MSL, so the caller
- * must keep the `StageCode` alive until `SDL_CreateGPUShader` has run.
- */
+/** Turn a SPIR-V stage into what the device consumes (SPIR-V or MSL text);
+ * `code` points into `text` for MSL, so `stage` must outlive the SDL shader. */
 bool prepare_stage(const std::vector<uint32_t> &spirv, bool fragment,
                    SDL_GPUShaderFormat formats, StageCode *stage, std::string *log) {
   if ((formats & SDL_GPU_SHADERFORMAT_MSL) != 0) {
-    if (!cross_compile_msl(spirv, fragment, &stage->text, &stage->entry, log)) return false;
+    const GpuShaderApi *api = gpu_shader_api();
+    if (api == nullptr) {
+      *log = "shader translation was not linked (the 'gpu' link feature is inactive)";
+      return false;
+    }
+    if (!api->cross_compile_msl(spirv, fragment, &stage->text, &stage->entry, log)) return false;
     stage->format = SDL_GPU_SHADERFORMAT_MSL;
     stage->code = (const Uint8 *)stage->text.data();
     stage->code_size = stage->text.size();
@@ -146,12 +141,18 @@ bool WebGLContext::compile_shader(uint32_t id) {
   WebGLShader *record = shader(id);
   if (record == nullptr) return false;
   const bool fragment = record->type == GL_FRAGMENT_SHADER;
+  const GpuShaderApi *api = gpu_shader_api();
+  if (api == nullptr) {
+    record->log = "shader translation was not linked (the 'gpu' link feature is inactive)";
+    record->compiled = false;
+    return false;
+  }
   /* Expand three.js's pragma-marked light loops first: a sampler-array index
    * must be constant in Vulkan GLSL, and the expansion is the only place that
    * knows the loop bounds. Scanning and rewriting then share one text. */
-  const std::string prepared = unroll_glsl_pragmas(record->source);
+  const std::string prepared = api->unroll_glsl_pragmas(record->source);
   GlslShaderInfo info;
-  scan_glsl(prepared, fragment, &info);
+  api->scan_glsl(prepared, fragment, &info);
   if (!info.unsupported.empty()) {
     record->log = info.unsupported;
     record->compiled = false;
@@ -162,9 +163,9 @@ bool WebGLContext::compile_shader(uint32_t id) {
   assign_locations(info.varyings, {}, &layout.varyings);
   assign_locations(info.samplers, {}, &layout.samplers);
   layout.block_members = info.uniforms;
-  const std::string source = rewrite_glsl(prepared, fragment, layout, info);
+  const std::string source = api->rewrite_glsl(prepared, fragment, layout, info);
   std::vector<uint32_t> spirv;
-  record->compiled = compile_glsl(source, fragment, &spirv, &record->log);
+  record->compiled = api->compile_glsl(source, fragment, &spirv, &record->log);
   return record->compiled;
 }
 
@@ -268,12 +269,19 @@ bool WebGLContext::link_program(uint32_t id) {
     return false;
   }
 
-  const std::string prepared_vertex = unroll_glsl_pragmas(vertex->source);
-  const std::string prepared_fragment = unroll_glsl_pragmas(fragment->source);
+  const GpuShaderApi *api = gpu_shader_api();
+  if (api == nullptr) {
+    record->log = "shader translation was not linked (the 'gpu' link feature is inactive)";
+    record->linked = false;
+    return false;
+  }
+
+  const std::string prepared_vertex = api->unroll_glsl_pragmas(vertex->source);
+  const std::string prepared_fragment = api->unroll_glsl_pragmas(fragment->source);
   GlslShaderInfo vs_info;
   GlslShaderInfo fs_info;
-  scan_glsl(prepared_vertex, false, &vs_info);
-  scan_glsl(prepared_fragment, true, &fs_info);
+  api->scan_glsl(prepared_vertex, false, &vs_info);
+  api->scan_glsl(prepared_fragment, true, &fs_info);
   if (!vs_info.unsupported.empty() || !fs_info.unsupported.empty()) {
     record->log = vs_info.unsupported.empty() ? fs_info.unsupported : vs_info.unsupported;
     record->linked = false;
@@ -342,17 +350,17 @@ bool WebGLContext::link_program(uint32_t id) {
   }
   fs_layout.varyings = vs_layout.varyings;
 
-  const std::string vs_source = rewrite_glsl(prepared_vertex, false, vs_layout, vs_info);
-  const std::string fs_source = rewrite_glsl(prepared_fragment, true, fs_layout, fs_info);
+  const std::string vs_source = api->rewrite_glsl(prepared_vertex, false, vs_layout, vs_info);
+  const std::string fs_source = api->rewrite_glsl(prepared_fragment, true, fs_layout, fs_info);
   std::vector<uint32_t> vs_spirv;
   std::vector<uint32_t> fs_spirv;
   std::string log;
-  if (!compile_glsl(vs_source, false, &vs_spirv, &log)) {
+  if (!api->compile_glsl(vs_source, false, &vs_spirv, &log)) {
     record->log = "vertex shader:\n" + log;
     record->linked = false;
     return false;
   }
-  if (!compile_glsl(fs_source, true, &fs_spirv, &log)) {
+  if (!api->compile_glsl(fs_source, true, &fs_spirv, &log)) {
     record->log = "fragment shader:\n" + log;
     record->linked = false;
     return false;
@@ -360,9 +368,9 @@ bool WebGLContext::link_program(uint32_t id) {
 
   /* Reflect the std140 block (members survive even when unused). */
   std::vector<GlslBlockMember> members;
-  reflect_uniform_block(vs_spirv, &members);
+  api->reflect_uniform_block(vs_spirv, &members);
   std::vector<GlslBlockMember> fragment_members;
-  reflect_uniform_block(fs_spirv, &fragment_members);
+  api->reflect_uniform_block(fs_spirv, &fragment_members);
   /* Keep members declared by either stage: a uniform block may only be read by
    * the fragment shader while the vertex stage contributes other uniforms. */
   for (const GlslBlockMember &member : fragment_members) {
@@ -380,7 +388,7 @@ bool WebGLContext::link_program(uint32_t id) {
    * declarations, so the source scan over-reports; use the reflection and keep
    * the declaration order from the source for stable `getActiveAttrib` order. */
   std::unordered_map<std::string, int> active_attributes;
-  reflect_attributes(vs_spirv, &active_attributes);
+  api->reflect_attributes(vs_spirv, &active_attributes);
   if (!active_attributes.empty()) {
     std::vector<std::pair<int, GlslUniformDecl>> ordered;
     for (const GlslUniformDecl &decl : vs_info.attributes) {

package/runtime/ext_gui/window.cpp

@@ -13,7 +13,7 @@
 
 #include <algorithm>
 
-#include "inline_svg.h"
+#include "image_api.h"
 #include "paint.h"
 #include "perf.h"
 #include "text.h"
@@ -252,17 +252,17 @@ static xt_value win_inline_svg(xt_value self, xt_value env, int32_t argc, xt_val
   const char *selector = xt_string_data(selectorValue);
   if (selector == nullptr) return XT_UNDEFINED;
   const xtgui::Node *node = win->document->querySelector(selector);
-  if (!xtgui::xt_inline_svg_is_root(node)) return XT_UNDEFINED;
-  std::string markup = xtgui::xt_inline_svg_serialize(node);
-  int width = 0;
-  int height = 0;
-  xtgui::xt_svg_markup_size(markup, &width, &height);
+  const XtImageApi *images = xt_image_api();
+  if (images == nullptr || !images->inline_is_root(node)) return XT_UNDEFINED;
+  std::string markup = images->inline_serialize(node, &win->document->styles());
+  int width = 0, height = 0;
+  images->svg_markup_size(markup, &width, &height);
   xt_value object = xt_object_new();
   xt_object_set(object, xt_string_from_cstr("markup"), xt_string_from_cstr(markup.c_str()));
   xt_object_set(object, xt_string_from_cstr("width"), xt_number(width));
   xt_object_set(object, xt_string_from_cstr("height"), xt_number(height));
   xt_object_set(object, xt_string_from_cstr("shapes"),
-                xt_number(xtgui::xt_svg_markup_shapes(markup)));
+                xt_number(images->svg_markup_shapes(markup)));
   return object;
 }
 

package/runtime/ext_media/decode_audio.cpp

@@ -1,5 +1,5 @@
 /*
- * xbintsc media extension — in-memory audio decoding.
+ * xbintsc media link feature — in-memory audio decoding.
  *
  * `AudioContext.decodeAudioData` hands over bytes, not a path, so the file
  * oriented `MediaPlayer` cannot be reused. This unit opens the bytes through a

package/runtime/ext_media/media.cpp

@@ -1,5 +1,5 @@
 /*
- * xbintsc media extension — `<video>`/`<audio>` decoding.
+ * xbintsc media link feature — `<video>`/`<audio>` decoding.
  *
  * This translation unit is the only place that knows about FFmpeg. It is
  * compiled into the prebuilt `media.a`/`media.lib` by `scripts/build-media.ts` and linked

package/runtime/ext_media/media_bridge.c

@@ -1,19 +1,19 @@
 /*
- * xbintsc media extension — registration bridge.
+ * xbintsc media link feature — registration bridge.
  *
  * The decoders live in `media.a` (`media.lib` with the MSVC ABI on Windows), a
  * prebuilt C++ archive. A static archive is
  * only searched for members that satisfy an undefined symbol, so a backend that
  * merely had a constructor would never be extracted. This tiny C translation
- * unit is compiled and linked *directly* (it is the media extension's
- * `runtimeSources()` entry): its constructor references every backend entry
+ * unit is compiled and linked *directly* — but only when the compiler selects
+ * the `media` feature (it is the feature's `runtimeSources()` entry): its
+ * constructor references every backend entry
  * point, which pulls the archive member in, and installs the table into the GUI
  * engine before `main` runs.
  *
- * The bridge is intentionally C-only and has no FFmpeg (or SDL) dependency. If
- * the `gui` extension is not enabled, `xt_media_install` is unresolved; the
- * registry rejects that combination first with a "media requires gui"
- * diagnostic (see `src/extensions/registry.ts`).
+ * The bridge is intentionally C-only and has no FFmpeg (or SDL) dependency. The
+ * feature belongs to `gui`, so it is only ever compiled with `gui` enabled;
+ * `xt_media_install` therefore always resolves.
  */
 
 #include "../ext_gui/media_api.h"