xbintsc 0.5.37 → 0.5.38

package/runtime/ext_gui/webgl_glsl_unroll.cpp

@@ -0,0 +1,283 @@
+/*
+ * xbintsc GUI engine — `#pragma unroll_loop_start` expansion.
+ *
+ * three.js marks its material light loops with
+ *
+ *     #pragma unroll_loop_start
+ *     for ( int i = 0; i < N; i ++ ) { ... UNROLLED_LOOP_INDEX ... [ i ] ... }
+ *     #pragma unroll_loop_end
+ *
+ * and expands them in JavaScript before upload. On this runtime the expansion
+ * is best done here: the loop body indexes sampler arrays (`shadowMap[ i ]`),
+ * and Vulkan GLSL only accepts a *constant* sampler-array index. Expanding the
+ * pragma turns every `i` (and `UNROLLED_LOOP_INDEX`) into a literal, so the
+ * shadow-map chunks compile without relying on the regex engine or on three.js
+ * having unrolled them first. WebGL ignores the unknown pragmas either way.
+ *
+ * The transformation is deliberately small: only the `for (int i = A; i < B;
+ * i ++)` shape three.js emits is recognised. Anything else is left untouched.
+ */
+
+#include "webgl_glsl.h"
+
+#include <cctype>
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+namespace xtgui {
+namespace {
+
+const char *const kStartPragma = "#pragma unroll_loop_start";
+const char *const kEndPragma = "#pragma unroll_loop_end";
+
+/** Skip whitespace and comments starting at `at`. */
+size_t skip_space(const std::string &text, size_t at) {
+  while (at < text.size()) {
+    const char c = text[at];
+    if (std::isspace((unsigned char)c) != 0) {
+      at++;
+      continue;
+    }
+    if (c == '/' && at + 1 < text.size() && text[at + 1] == '/') {
+      at += 2;
+      while (at < text.size() && text[at] != '\n') at++;
+      continue;
+    }
+    if (c == '/' && at + 1 < text.size() && text[at + 1] == '*') {
+      at += 2;
+      while (at + 1 < text.size() && !(text[at] == '*' && text[at + 1] == '/')) at++;
+      if (at + 1 < text.size()) at += 2;
+      continue;
+    }
+    break;
+  }
+  return at;
+}
+
+/** Index just past the end of a `//` / `#` line starting at `at`. */
+size_t line_end(const std::string &text, size_t at) {
+  while (at < text.size() && text[at] != '\n') at++;
+  return at;
+}
+
+/** Match the `}` for the `{` at `open`, skipping comments. */
+size_t matching_brace(const std::string &text, size_t open, size_t *out) {
+  int depth = 0;
+  for (size_t i = open; i < text.size(); i++) {
+    const char c = text[i];
+    if (c == '/' && i + 1 < text.size() && text[i + 1] == '/') {
+      i += 2;
+      while (i < text.size() && text[i] != '\n') i++;
+      if (i < text.size()) continue;
+      break;
+    }
+    if (c == '/' && i + 1 < text.size() && text[i + 1] == '*') {
+      i += 2;
+      while (i + 1 < text.size() && !(text[i] == '*' && text[i + 1] == '/')) i++;
+      if (i + 1 < text.size()) i++;
+      continue;
+    }
+    if (c == '{') depth++;
+    if (c == '}') {
+      depth--;
+      if (depth == 0) {
+        *out = i;
+        return i;
+      }
+    }
+  }
+  return std::string::npos;
+}
+
+struct LoopHeader {
+  std::string variable;
+  long start = 0;
+  long end = 0;
+  bool inclusive = false;
+};
+
+/** Tokenise a for-header into identifiers, numbers and punctuation. */
+std::vector<std::string> tokens(const std::string &text) {
+  std::vector<std::string> out;
+  size_t i = 0;
+  while (i < text.size()) {
+    const char c = text[i];
+    if (std::isspace((unsigned char)c) != 0) {
+      i++;
+      continue;
+    }
+    if (std::isalnum((unsigned char)c) != 0 || c == '_') {
+      size_t end = i + 1;
+      while (end < text.size() &&
+             (std::isalnum((unsigned char)text[end]) != 0 || text[end] == '_')) {
+        end++;
+      }
+      out.push_back(text.substr(i, end - i));
+      i = end;
+      continue;
+    }
+    if ((c == '+' && i + 1 < text.size() && text[i + 1] == '+') ||
+        (c == '-' && i + 1 < text.size() && text[i + 1] == '-')) {
+      out.push_back(text.substr(i, 2));
+      i += 2;
+      continue;
+    }
+    if ((c == '+' || c == '-' || c == '<' || c == '=' || c == '!') && i + 1 < text.size() &&
+        text[i + 1] == '=') {
+      out.push_back(text.substr(i, 2));
+      i += 2;
+      continue;
+    }
+    out.push_back(std::string(1, c));
+    i++;
+  }
+  return out;
+}
+
+bool parse_header(const std::string &header, LoopHeader *out) {
+  std::vector<std::string> parts = tokens(header);
+  size_t at = 0;
+  /* Optional qualifiers (`int`, `uint`, `highp int`, …). */
+  while (at < parts.size() && (parts[at] == "int" || parts[at] == "uint" || parts[at] == "highp" ||
+                              parts[at] == "mediump" || parts[at] == "lowp")) {
+    at++;
+  }
+  if (at >= parts.size()) return false;
+  out->variable = parts[at++];
+  if (at >= parts.size() || parts[at] != "=") return false;
+  at++;
+  if (at >= parts.size()) return false;
+  char *end = nullptr;
+  out->start = std::strtol(parts[at].c_str(), &end, 10);
+  if (end == nullptr || *end != 0) return false;
+  at++;
+  if (at >= parts.size() || parts[at] != ";") return false;
+  at++;
+  /* `i < N` / `i <= N`; the repeated variable may be spelled differently. */
+  if (at >= parts.size()) return false;
+  at++;
+  if (at >= parts.size()) return false;
+  out->inclusive = parts[at] == "<=";
+  if (!out->inclusive && parts[at] != "<") return false;
+  at++;
+  if (at >= parts.size()) return false;
+  out->end = std::strtol(parts[at].c_str(), &end, 10);
+  if (end == nullptr || *end != 0) return false;
+  at++;
+  if (at >= parts.size() || parts[at] != ";") return false;
+  at++;
+  if (at >= parts.size()) return false;
+  at++;
+  if (at >= parts.size() || parts[at] != "++") return false;
+  return true;
+}
+
+/** Replace whole-word `name` with `value`. */
+std::string substitute(const std::string &body, const std::string &name, long value) {
+  const std::string text = std::to_string(value);
+  std::string out;
+  out.reserve(body.size());
+  size_t i = 0;
+  while (i < body.size()) {
+    const char c = body[i];
+    if (std::isalpha((unsigned char)c) == 0 && c != '_') {
+      out += c;
+      i++;
+      continue;
+    }
+    size_t end = i + 1;
+    while (end < body.size() &&
+           (std::isalnum((unsigned char)body[end]) != 0 || body[end] == '_')) {
+      end++;
+    }
+    const std::string word = body.substr(i, end - i);
+    if (word == name || word == "UNROLLED_LOOP_INDEX") {
+      out += text;
+    } else {
+      out += word;
+    }
+    i = end;
+  }
+  return out;
+}
+
+}  // namespace
+
+std::string unroll_glsl_pragmas(const std::string &source) {
+  if (source.find(kStartPragma) == std::string::npos) return source;
+  std::string result;
+  size_t cursor = 0;
+  while (cursor < source.size()) {
+    const size_t pragma = source.find(kStartPragma, cursor);
+    if (pragma == std::string::npos) {
+      result.append(source, cursor, std::string::npos);
+      break;
+    }
+    result.append(source, cursor, pragma - cursor);
+    size_t at = line_end(source, pragma + std::string(kStartPragma).size());
+    const size_t after_header = skip_space(source, at);
+    if (source.compare(after_header, 3, "for") != 0) {
+      /* Not the shape three.js emits: keep the pragma and move on. */
+      result.append(source, pragma, at - pragma);
+      cursor = at;
+      continue;
+    }
+    size_t open_paren = skip_space(source, after_header + 3);
+    if (open_paren >= source.size() || source[open_paren] != '(') {
+      result.append(source, pragma, at - pragma);
+      cursor = at;
+      continue;
+    }
+    int depth = 0;
+    size_t close_paren = open_paren;
+    for (; close_paren < source.size(); close_paren++) {
+      if (source[close_paren] == '(') depth++;
+      if (source[close_paren] == ')') {
+        depth--;
+        if (depth == 0) break;
+      }
+    }
+    if (close_paren >= source.size()) {
+      result.append(source, pragma, at - pragma);
+      cursor = at;
+      continue;
+    }
+    LoopHeader loop;
+    if (!parse_header(source.substr(open_paren + 1, close_paren - open_paren - 1), &loop) ||
+        loop.end < loop.start || loop.end - loop.start > 4096) {
+      result.append(source, pragma, at - pragma);
+      cursor = at;
+      continue;
+    }
+    size_t open_brace = skip_space(source, close_paren + 1);
+    if (open_brace >= source.size() || source[open_brace] != '{') {
+      result.append(source, pragma, at - pragma);
+      cursor = at;
+      continue;
+    }
+    size_t close_brace = 0;
+    if (matching_brace(source, open_brace, &close_brace) == std::string::npos) {
+      result.append(source, pragma, at - pragma);
+      cursor = at;
+      continue;
+    }
+    size_t end = skip_space(source, close_brace + 1);
+    if (source.compare(end, std::string(kEndPragma).size(), kEndPragma) != 0) {
+      result.append(source, pragma, at - pragma);
+      cursor = at;
+      continue;
+    }
+    end = line_end(source, end + std::string(kEndPragma).size());
+    const std::string body = source.substr(open_brace + 1, close_brace - open_brace - 1);
+    const long last = loop.inclusive ? loop.end : loop.end - 1;
+    for (long i = loop.start; i <= last; i++) {
+      result += substitute(body, loop.variable, i);
+      result += '\n';
+    }
+    cursor = end;
+  }
+  return result;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_msl.cpp

@@ -36,6 +36,10 @@ bool cross_compile_msl(const std::vector<uint32_t> &spirv, bool fragment,
      * 0..num_samplers-1, so any other allocation would sample the wrong
      * texture (or none at all). */
     options.enable_decoration_binding = true;
+    /* Sampler arrays (three.js shadow maps) need MSL 2.0: with the default
+     * 1.2 target SPIRV-Cross rejects "MSL 2.0 or greater is required for
+     * arrays of textures". Every Metal device SDL_GPU runs on supports 2.0. */
+    options.msl_version = spirv_cross::CompilerMSL::Options::make_msl_version(2, 0);
     compiler.set_msl_options(options);
     *source = compiler.compile();
     *entry = compiler.get_cleansed_entry_point_name(

package/runtime/ext_gui/webgl_shader.cpp

@@ -174,8 +174,12 @@ bool WebGLContext::compile_shader(uint32_t id) {
   WebGLShader *record = shader(id);
   if (record == nullptr) return false;
   const bool fragment = record->type == GL_FRAGMENT_SHADER;
+  /* 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);
   GlslShaderInfo info;
-  scan_glsl(record->source, fragment, &info);
+  scan_glsl(prepared, fragment, &info);
   if (!info.unsupported.empty()) {
     record->log = info.unsupported;
     record->compiled = false;
@@ -186,7 +190,7 @@ 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(record->source, fragment, layout, info);
+  const std::string source = rewrite_glsl(prepared, fragment, layout, info);
   std::vector<uint32_t> spirv;
   record->compiled = compile_glsl(source, fragment, &spirv, &record->log);
   return record->compiled;
@@ -289,10 +293,12 @@ 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);
   GlslShaderInfo vs_info;
   GlslShaderInfo fs_info;
-  scan_glsl(vertex->source, false, &vs_info);
-  scan_glsl(fragment->source, true, &fs_info);
+  scan_glsl(prepared_vertex, false, &vs_info);
+  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;
@@ -361,8 +367,8 @@ bool WebGLContext::link_program(uint32_t id) {
   }
   fs_layout.varyings = vs_layout.varyings;
 
-  const std::string vs_source = rewrite_glsl(vertex->source, false, vs_layout, vs_info);
-  const std::string fs_source = rewrite_glsl(fragment->source, true, fs_layout, fs_info);
+  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);
   std::vector<uint32_t> vs_spirv;
   std::vector<uint32_t> fs_spirv;
   std::string log;

package/runtime/rt.h

@@ -305,6 +305,9 @@ xt_value xt_date_static(xt_value name, int32_t argc, xt_value *argv);
 xt_value xt_regexp_ctor(int32_t argc, xt_value *argv);
 
 /* -- node:url ------------------------------------------------------------- */
+xt_value xt_url_ctor(int32_t argc, xt_value *argv);
+/** Resolve a `fetch` reference to a filesystem path (file: URLs and relative paths). */
+int xt_url_file_path(const char *url, char *out, size_t size);
 xt_value xt_url_path_to_file_url(int32_t argc, xt_value *argv);
 xt_value xt_url_file_url_to_path(int32_t argc, xt_value *argv);
 

package/runtime/xt_fetch/async.inc

@@ -201,6 +201,66 @@ static void xt_fetch_hop_complete(xt_async_job *job) {
 
 /* Main thread: validate the current URL and queue one exchange. */
 static void xt_fetch_start(xt_fetch_state *state) {
+  /* `file:` URLs and references with no scheme (a relative path) read a local
+   * file. This is what lets a compiled page load an asset from disk without an
+   * HTTP server; the response is built on this thread because a local read is
+   * already complete. */
+  char path[4096];
+  if (xt_url_file_path(state->url, path, sizeof(path))) {
+    if (strcmp(state->method, "GET") != 0 && strcmp(state->method, "HEAD") != 0) {
+      xt_fetch_state_reject(state, "fetch failed: file URLs only support GET or HEAD");
+      return;
+    }
+    FILE *file = fopen(path, "rb");
+    if (!file) {
+      xt_fetch_state_reject(state, "fetch failed: cannot read file");
+      return;
+    }
+    size_t capacity = 0;
+    size_t length = 0;
+    char *body = NULL;
+    char chunk[16384];
+    for (;;) {
+      size_t count = fread(chunk, 1, sizeof(chunk), file);
+      if (count > 0) {
+        if (length + count + 1 > capacity) {
+          capacity = (length + count + 1) * 2;
+          char *grown = (char *)realloc(body, capacity);
+          if (!grown) {
+            free(body);
+            fclose(file);
+            xt_fetch_state_reject(state, "fetch failed");
+            return;
+          }
+          body = grown;
+        }
+        memcpy(body + length, chunk, count);
+        length += count;
+      }
+      if (count < sizeof(chunk)) break;
+    }
+    fclose(file);
+
+    char href[4300];
+    if (path[0] == '/') {
+      snprintf(href, sizeof(href), "file://%s", path);
+    } else {
+      snprintf(href, sizeof(href), "file:///%s", path);
+    }
+    xt_value headers = xt_headers_new();
+    char lengthText[32];
+    snprintf(lengthText, sizeof(lengthText), "%zu", length);
+    xt_headers_set_raw(headers, "content-length", lengthText);
+    xt_headers_set_raw(headers, "content-type", "application/octet-stream");
+    size_t bodyLength = strcmp(state->method, "HEAD") == 0 ? 0 : length;
+    xt_value response = xt_response_new(headers, 200, "OK", href, body, bodyLength);
+    free(body);
+    xt_value promise = state->promise;
+    xt_fetch_state_free(state);
+    xt_promise_fulfill(promise, response);
+    return;
+  }
+
   xt_fetch_url parsed;
   if (xt_fetch_parse_url(state->url, &parsed) != 0) {
     xt_fetch_state_reject(state, "Failed to parse URL");