xbintsc 0.5.38 → 0.5.41

package/runtime/ext_gui/webgl_shader.cpp

@@ -22,36 +22,8 @@
 namespace xtgui {
 namespace {
 
-int gl_type_of(const std::string &type) {
-  if (type == "float") return GL_FLOAT;
-  if (type == "vec2") return GL_FLOAT_VEC2;
-  if (type == "vec3") return GL_FLOAT_VEC3;
-  if (type == "vec4") return GL_FLOAT_VEC4;
-  if (type == "int" || type == "uint") return GL_INT;
-  if (type == "ivec2" || type == "uvec2") return GL_INT_VEC2;
-  if (type == "ivec3" || type == "uvec3") return GL_INT_VEC3;
-  if (type == "ivec4" || type == "uvec4") return GL_INT_VEC4;
-  if (type == "bool") return GL_BOOL;
-  if (type == "bvec2") return GL_BOOL_VEC2;
-  if (type == "bvec3") return GL_BOOL_VEC3;
-  if (type == "bvec4") return GL_BOOL_VEC4;
-  if (type == "mat2") return GL_FLOAT_MAT2;
-  if (type == "mat3") return GL_FLOAT_MAT3;
-  if (type == "mat4") return GL_FLOAT_MAT4;
-  if (type == "sampler2D") return GL_SAMPLER_2D;
-  if (type == "samplerCube") return GL_SAMPLER_CUBE;
-  if (type == "sampler3D") return GL_SAMPLER_3D;
-  if (type == "sampler2DArray") return GL_SAMPLER_2D_ARRAY;
-  return 0;
-}
-
-/** How many consecutive attribute/varying locations a type consumes. */
-int location_slots(const std::string &type) {
-  if (type == "mat2") return 2;
-  if (type == "mat3") return 3;
-  if (type == "mat4") return 4;
-  return 1;
-}
+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,
@@ -232,6 +204,9 @@ void WebGLContext::release_program_pipelines(WebGLProgram *program) {
   if (program->fs_shader != nullptr) SDL_ReleaseGPUShader(guidev::g_device, program->fs_shader);
   program->vs_shader = nullptr;
   program->fs_shader = nullptr;
+  /* Prepared draws hold pipeline pointers too; a relink reuses the same program
+   * id, so they must not be served from the cache after this. */
+  clear_draw_cache();
 }
 
 void WebGLContext::delete_program(uint32_t id) {
@@ -425,6 +400,19 @@ bool WebGLContext::link_program(uint32_t id) {
   record->vs_sampler_uniforms.clear();
   record->fs_sampler_uniforms.clear();
 
+  /* Resolve the active attributes once: a draw then iterates this plan instead
+   * of re-scanning `attribs` and hashing every attribute name again. */
+  record->draw_attribs.clear();
+  record->draw_attribs.reserve(record->attribs.size());
+  for (const GlslUniformDecl &decl : record->attribs) {
+    auto found = record->attrib_locations.find(decl.name);
+    if (found == record->attrib_locations.end()) continue;
+    WebGLDrawAttribPlan plan;
+    plan.location = found->second;
+    plan.type = decl.type;
+    record->draw_attribs.push_back(plan);
+  }
+
   for (const GlslBlockMember &member : members) {
     WebGLUniform uniform;
     uniform.name = member.name;
@@ -442,14 +430,18 @@ bool WebGLContext::link_program(uint32_t id) {
 
   auto add_sampler = [](WebGLProgram *program, std::vector<int> *stage,
                         const GlslUniformDecl &decl) {
+    const bool compare = decl.type == "sampler2DShadow" || decl.type == "samplerCubeShadow" ||
+                         decl.type == "sampler2DArrayShadow";
     int index = -1;
     auto found = program->uniform_index.find(decl.name);
     if (found != program->uniform_index.end()) {
       index = found->second;
+      program->uniforms[(size_t)index].compare = compare;
     } else {
       WebGLUniform uniform;
       uniform.name = decl.name;
       uniform.sampler = true;
+      uniform.compare = compare;
       uniform.unit = 0;
       uniform.layout.gl_type = gl_type_of(decl.type);
       index = (int)program->uniforms.size();

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/src/codegen/generator/module.ts

@@ -160,6 +160,18 @@ export const moduleMethods: ModuleMethods = {
       );
     }
 
+    // Captures threaded through the environment. Declared before the
+    // parameters because a default parameter may read an enclosing binding
+    // (e.g. `constructor(wrapS = ClampToEdgeWrapping)`), and a capture has no
+    // other slot to read.
+    for (const symbol of fn.captures) {
+      if (this.moduleGlobals.has(symbol.id)) continue;
+      const index = fn.captureIndex.get(symbol.id)!;
+      const value = this.reg();
+      this.emit(`  ${value} = call i64 @xt_closure_env(i64 %env, i32 ${index})`);
+      this.defineCaptureSlot(symbol, value);
+    }
+
     // Parameters.
     const parameterNodes = (fn.node as { parameters?: Parameter[] }).parameters ?? [];
     for (let index = 0; index < fn.params.length; index++) {
@@ -185,13 +197,16 @@ export const moduleMethods: ModuleMethods = {
       if (parameter.initializer) this.emitDefaultParameter(symbol, value, parameter.initializer);
     }
 
-    // Captures threaded through the environment.
-    for (const symbol of fn.captures) {
-      if (this.moduleGlobals.has(symbol.id)) continue;
-      const index = fn.captureIndex.get(symbol.id)!;
-      const value = this.reg();
-      this.emit(`  ${value} = call i64 @xt_closure_env(i64 %env, i32 ${index})`);
-      this.defineCaptureSlot(symbol, value);
+    // Boxed bindings declared in this frame get their box now, before any
+    // statement runs. A closure built earlier in the body — a class's methods
+    // are installed by the class statement, which may precede the `const` the
+    // method reads — captures the box pointer, so the later declaration fills
+    // the same box. Without this the closure would capture an undefined slot
+    // (Three.js declares `_zero`/`_one` after the class that uses them).
+    for (const symbol of fn.locals) {
+      if (!symbol.boxed || this.moduleGlobals.has(symbol.id)) continue;
+      if (this.current.slots.has(symbol.id)) continue;
+      this.declareSlot(symbol, i64(XT_UNDEFINED));
     }
 
     // Hoisted function declarations: create their closure values in this

package/src/driver/version.ts

@@ -9,4 +9,4 @@
  * `main`/`master` only (see `.githooks/pre-commit`), so feature branches never
  * change this line and merging two of them cannot conflict here.
  */
-export const COMPILER_VERSION = "0.5.38";
+export const COMPILER_VERSION = "0.5.41";

package/src/extensions/gui/html.ts

@@ -163,7 +163,10 @@ function deferredPrelude(alias: string, declaration: ImportDeclaration): string[
 
 /** Split an external script module into hoisted imports and a body. */
 function compileModuleSource(htmlPath: string, scriptPath: string, scriptIndex: number): CompiledModule {
-  const source = readFileSync(scriptPath, "utf8");
+  /* Mask the normalized text: the parser indexes the `SourceFile` text, where
+   * `\r\n` already became `\n`, so blanking statement spans in the raw file
+   * would remove the wrong characters on a CRLF checkout. */
+  const source = new SourceFile(scriptPath, readFileSync(scriptPath, "utf8")).text;
   const bag = new DiagnosticBag();
   const parsed = new Parser(new SourceFile(scriptPath, source), bag).parseSourceFile();
   const chars = source.split("");
@@ -256,6 +259,10 @@ function resolveScriptPath(htmlPath: string, src: string): string {
 
 /** Rewrite `<script>` bodies into registered AOT functions + an HTML string. */
 export function loadHtmlAsset(path: string, source: string): AssetLoadResult {
+  /* The generated module is parsed as a `SourceFile`, which rewrites `\r\n` to
+   * `\n`; normalize first so the module text, the offsets recorded for
+   * `<script src>` bodies and the exported HTML string all share one layout. */
+  const page = new SourceFile(path, source).text;
   /* `file` is set for an external `<script src>`: its body keeps that file as
    * the origin of every node, so a `.js` script stays untyped and diagnostics
    * name the script, not the HTML page. */
@@ -267,7 +274,7 @@ export function loadHtmlAsset(path: string, source: string): AssetLoadResult {
 
   /* The engine's cascade only reads `<style>` elements, so a linked stylesheet
    * would be dropped at runtime. Inline it (and its `@import`s) now. */
-  const styles = inlineStylesheets(path, source);
+  const styles = inlineStylesheets(path, page);
   const html = styles.html.replace(SCRIPT_RE, (match, attributes: string, inlineBody: string) => {
     if (!isExecutable(attribute(attributes, "type"), attribute(attributes, "lang"))) return match;
     const src = attribute(attributes, "src");