xbintsc 0.5.37 → 0.5.41

package/runtime/ext_gui/webgl_webgl2.cpp

@@ -78,6 +78,7 @@ void WebGLContext::save_vertex_array() {
 void WebGLContext::load_vertex_array(const WebGLVertexArray *array) {
   for (int i = 0; i < kWebGLMaxAttribs; i++) attribs_[i] = array->attribs[i];
   bound_element_ = array->element_buffer;
+  attribs_version_ += 1;
 }
 
 void WebGLContext::bind_vertex_array(uint32_t id) {
@@ -238,6 +239,11 @@ bool WebGLContext::sampler_parameter(uint32_t id, int pname, int value) {
   else if (pname == GL_TEXTURE_MAG_FILTER) record->mag_filter = value;
   else if (pname == GL_TEXTURE_WRAP_S) record->wrap_s = value;
   else if (pname == GL_TEXTURE_WRAP_T) record->wrap_t = value;
+  else if (pname == GL_TEXTURE_COMPARE_MODE) {
+    record->compare_mode = value == GL_COMPARE_REF_TO_TEXTURE;
+  } else if (pname == GL_TEXTURE_COMPARE_FUNC) {
+    record->compare_func = value;
+  }
   if (record->gpu != nullptr && guidev::g_device != nullptr) {
     SDL_ReleaseGPUSampler(guidev::g_device, record->gpu);
     record->gpu = nullptr;
@@ -252,6 +258,10 @@ int WebGLContext::sampler_parameter_value(uint32_t id, int pname) {
   if (pname == GL_TEXTURE_MAG_FILTER) return record->mag_filter;
   if (pname == GL_TEXTURE_WRAP_S) return record->wrap_s;
   if (pname == GL_TEXTURE_WRAP_T) return record->wrap_t;
+  if (pname == GL_TEXTURE_COMPARE_MODE) {
+    return record->compare_mode ? GL_COMPARE_REF_TO_TEXTURE : GL_NONE;
+  }
+  if (pname == GL_TEXTURE_COMPARE_FUNC) return record->compare_func;
   return 0;
 }
 
@@ -270,6 +280,32 @@ SDL_GPUSampler *WebGLContext::sampler_gpu(WebGLSampler *record) {
   /* A sampler object has no texture, so it cannot know how many levels exist;
    * textures created by this engine always carry a full mip chain. */
   info.max_lod = 1000.0f;
+  if (record->compare_mode) {
+    info.enable_compare = true;
+    switch (record->compare_func) {
+      case GL_NEVER:
+        info.compare_op = SDL_GPU_COMPAREOP_NEVER;
+        break;
+      case GL_LESS:
+        info.compare_op = SDL_GPU_COMPAREOP_LESS;
+        break;
+      case GL_EQUAL:
+        info.compare_op = SDL_GPU_COMPAREOP_EQUAL;
+        break;
+      case GL_GREATER:
+        info.compare_op = SDL_GPU_COMPAREOP_GREATER;
+        break;
+      case GL_NOTEQUAL:
+        info.compare_op = SDL_GPU_COMPAREOP_NOT_EQUAL;
+        break;
+      case GL_GEQUAL:
+        info.compare_op = SDL_GPU_COMPAREOP_GREATER_OR_EQUAL;
+        break;
+      default:
+        info.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL;
+        break;
+    }
+  }
   record->gpu = SDL_CreateGPUSampler(guidev::g_device, &info);
   return record->gpu;
 }

package/runtime/ext_gui/window.cpp

@@ -15,6 +15,7 @@
 
 #include "inline_svg.h"
 #include "paint.h"
+#include "perf.h"
 #include "text.h"
 
 static xt_value g_window_proto = XT_UNDEFINED;
@@ -72,10 +73,15 @@ static xt_value win_load_html(xt_value self, xt_value env, int32_t argc, xt_valu
     xt_gui_window_viewport(win, &width, &height);
     win->document->load(html, width, height);
     win->geometry.dirty = 1;
+    win->present_dirty = 1;
     /* Run the AOT-compiled `<script>` bodies now that the tree is parsed, so
      * `document.getElementById(...)` resolves, then settle the first layout. */
     xt_gui_run_scripts(win);
     xt_gui_flush_dom(win);
+    /* The document was replaced, so the frame loop must reconcile the media
+     * and canvas tables with it on the next frame. `loadHTML` already flushed
+     * the style/layout, so this is a sync request, not a restyle. */
+    win->sync_dirty = 1;
   }
   xt_object_set(self, xt_string_from_cstr("__xt_gui_html"), xt_string_from_cstr(html.c_str()));
   /* Painting the document is milestone M3b+; the parsed tree and computed
@@ -199,6 +205,7 @@ static xt_value win_set_background(xt_value self, xt_value env, int32_t argc, xt
         win->background[1] = color.g;
         win->background[2] = color.b;
         win->background[3] = color.a;
+        win->present_dirty = 1;
       }
     }
     xt_object_set(self, xt_string_from_cstr("__xt_gui_background"), text);
@@ -265,7 +272,10 @@ static xt_value win_advance(xt_value self, xt_value env, int32_t argc, xt_value
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win == nullptr || win->document == nullptr) return XT_UNDEFINED;
   double ms = argc > 0 ? xt_to_number(xt_arg(argc, argv, 0)) : 0.0;
-  if (win->document->advance(ms)) win->geometry.dirty = 1;
+  if (win->document->advance(ms)) {
+    win->geometry.dirty = 1;
+    win->present_dirty = 1;
+  }
   return XT_UNDEFINED;
 }
 
@@ -481,6 +491,51 @@ static xt_value win_stats(xt_value self, xt_value env, int32_t argc, xt_value *a
                 xt_number(win != nullptr ? (double)win->node_order.size() : 0));
   xt_object_set(object, xt_string_from_cstr("listeners"),
                 xt_number(win != nullptr ? (double)win->node_listeners.size() : 0));
+  /* -- renderer counters (see `perf.h`) ---------------------------------- */
+  /* The `*Ms` values describe the last completed frame; every other counter is
+   * cumulative (diff two calls to get the work one frame did). */
+  const xtgui::PerfTimings &ms = xtgui::g_perf_last;
+  xt_object_set(object, xt_string_from_cstr("frameMs"), xt_number(ms.frame));
+  xt_object_set(object, xt_string_from_cstr("restyleMs"), xt_number(ms.restyle));
+  xt_object_set(object, xt_string_from_cstr("layoutMs"), xt_number(ms.layout));
+  xt_object_set(object, xt_string_from_cstr("paintMs"), xt_number(ms.paint));
+  xt_object_set(object, xt_string_from_cstr("uploadMs"), xt_number(ms.upload));
+  xt_object_set(object, xt_string_from_cstr("drawMs"), xt_number(ms.draw));
+  const xtgui::PerfCounters &counters = xtgui::g_perf_total;
+  auto setCounter = [&object](const char *name, uint64_t value) {
+    xt_object_set(object, xt_string_from_cstr(name), xt_number((double)value));
+  };
+  setCounter("frames", counters.frames);
+  setCounter("presents", counters.presents);
+  setCounter("exposes", counters.exposes);
+  setCounter("deferred", counters.deferred);
+  setCounter("starvedFrames", counters.starvedFrames);
+  setCounter("skippedFrames", counters.skippedFrames);
+  setCounter("restyles", counters.restyles);
+  setCounter("restyleNodes", counters.restyleNodes);
+  setCounter("rulesEvaluated", counters.rulesEvaluated);
+  setCounter("mediaEvaluated", counters.mediaEvaluated);
+  setCounter("layouts", counters.layouts);
+  setCounter("layoutBoxes", counters.layoutBoxes);
+  setCounter("textShapeCalls", counters.textShapeCalls);
+  setCounter("textShapeHits", counters.textShapeHits);
+  setCounter("textCacheBytes", xtgui::xt_text_cache_bytes());
+  setCounter("textCacheEntries", xtgui::xt_text_cache_entries());
+  setCounter("paints", counters.paints);
+  setCounter("paintOps", counters.paintOps);
+  setCounter("drawRuns", counters.drawRuns);
+  setCounter("drawCalls", counters.drawCalls);
+  setCounter("uploadSubmits", counters.uploadSubmits);
+  setCounter("vertices", counters.vertices);
+  setCounter("syncNodes", counters.syncNodes);
+  setCounter("transitionFrames", counters.transitionFrames);
+  setCounter("canvasDraws", counters.canvasDraws);
+  setCounter("canvasUploads", counters.canvasUploads);
+  setCounter("canvasUploadBytes", counters.canvasUploadBytes);
+  setCounter("webglDraws", counters.webglDraws);
+  setCounter("webglPasses", counters.webglPasses);
+  setCounter("webglPipelineMisses", counters.webglPipelineMisses);
+  setCounter("webglBufferUploadBytes", counters.webglBufferUploadBytes);
   return object;
 }
 

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");