xbintsc 0.5.37 → 0.5.41

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_objects.h

@@ -0,0 +1,148 @@
+/*
+ * xbintsc GUI engine — WebGL object records.
+ *
+ * Handles are integer ids, not pointers: a `deleteBuffer`/`deleteTexture` call
+ * must make an old JavaScript handle a no-op rather than a dangling pointer.
+ * Every record keeps its CPU-side data (buffer bytes, texture parameters) and
+ * the GPU handle it was last uploaded into.
+ *
+ * Split out of `webgl.h` to keep the context header under the repository's
+ * file-length budget; the context owns the tables of these records.
+ */
+#ifndef XT_GUI_WEBGL_OBJECTS_H
+#define XT_GUI_WEBGL_OBJECTS_H
+
+#include <cstdint>
+#include <vector>
+
+#include <SDL3/SDL.h>
+
+#include "webgl2_constants.h"
+#include "webgl_constants.h"
+
+namespace xtgui {
+
+constexpr int kWebGLMaxAttribs = 16;
+constexpr int kWebGLMaxTextureUnits = 16;
+constexpr int kWebGLMaxDrawBuffers = 4;
+
+struct WebGLBuffer {
+  uint32_t id = 0;
+  std::vector<uint8_t> data;
+  SDL_GPUBuffer *gpu = nullptr;
+  uint32_t capacity = 0;
+  bool dirty = true;
+  /** Half-open byte range of `data` that changed since the last GPU upload. */
+  uint32_t dirty_lo = 0;
+  uint32_t dirty_hi = 0;
+  /** `bufferData` usage hint, reported by `getBufferParameter`. */
+  int usage = GL_STATIC_DRAW;
+};
+
+struct WebGLTexture {
+  uint32_t id = 0;
+  int width = 0;
+  int height = 0;
+  int levels = 1;
+  /** The binding target this texture was created for. */
+  int target = GL_TEXTURE_2D;
+  /** Layers for a cube/2D-array texture, depth for a 3D texture. */
+  int layers = 1;
+  SDL_GPUTexture *gpu = nullptr;
+  SDL_GPUTextureFormat format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  /** Depth(-stencil) formats can only be depth attachments. */
+  bool depth = false;
+  /** Block-compressed textures are sample-only, with one mip level. */
+  bool compressed = false;
+  /** Usage flags the current `gpu` texture was created with. */
+  uint32_t usage = 0;
+  bool as_target = false;        // bound as a colour attachment
+  bool as_depth_target = false;  // bound as a depth attachment
+  bool has_mipmaps = false;
+  int min_filter = 0;
+  int mag_filter = 0;
+  int wrap_s = 0;
+  int wrap_t = 0;
+  SDL_GPUSampler *sampler = nullptr;
+  /** Comparison sampler for a `sampler2DShadow` binding. */
+  SDL_GPUSampler *compare_sampler = nullptr;
+  bool compare_mode = false;
+  int compare_func = GL_LEQUAL;
+  bool dirty = false;
+  bool defined = false;
+};
+
+struct WebGLRenderbuffer {
+  uint32_t id = 0;
+  int width = 0;
+  int height = 0;
+  bool stencil = false;
+  SDL_GPUTexture *depth = nullptr;
+};
+
+struct WebGLFramebuffer {
+  uint32_t id = 0;
+  uint32_t color_textures[kWebGLMaxDrawBuffers] = {};
+  /** Layer rendered to for an array/cube colour attachment. */
+  int color_layers[kWebGLMaxDrawBuffers] = {};
+  /** `COLOR_ATTACHMENTi` or `NONE` per draw-buffer slot. */
+  int draw_buffers[kWebGLMaxDrawBuffers] = {GL_COLOR_ATTACHMENT0, GL_NONE, GL_NONE, GL_NONE};
+  uint32_t depth_texture = 0;
+  uint32_t depth_renderbuffer = 0;
+  int width = 0;
+  int height = 0;
+  SDL_GPUTexture *depth = nullptr;  // owned when no renderbuffer/texture supplies one
+};
+
+/** Per-attribute array state. */
+struct WebGLAttribState {
+  bool enabled = false;
+  bool integer = false;  // `vertexAttribIPointer` rather than `vertexAttribPointer`
+  uint32_t buffer = 0;
+  int size = 4;
+  int type = GL_FLOAT;
+  bool normalized = false;
+  int stride = 0;
+  int offset = 0;
+  int divisor = 0;  // 0 = per vertex, 1 = per instance
+  float current[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+  /** GPU buffer holding `current[]` while this attribute is disabled. It is
+   * created lazily and re-uploaded only when `attrib_value` changes, so a draw
+   * never creates a GPU buffer just to supply a constant attribute. */
+  SDL_GPUBuffer *constant_gpu = nullptr;
+  uint32_t constant_bytes = 0;
+  bool constant_dirty = true;
+};
+
+/** A WebGL 2 vertex-array object; binding one restores this state. */
+struct WebGLVertexArray {
+  uint32_t id = 0;
+  WebGLAttribState attribs[kWebGLMaxAttribs];
+  uint32_t element_buffer = 0;
+};
+
+/** A WebGL 2 sampler object, bound to a texture unit with `bindSampler`. */
+struct WebGLSampler {
+  uint32_t id = 0;
+  int min_filter = 0;
+  int mag_filter = 0;
+  int wrap_s = 0;
+  int wrap_t = 0;
+  /** `TEXTURE_COMPARE_MODE`/`TEXTURE_COMPARE_FUNC` (WebGL 2 sampler objects
+   * carry them too). */
+  bool compare_mode = false;
+  int compare_func = GL_LEQUAL;
+  SDL_GPUSampler *gpu = nullptr;
+};
+
+struct WebGLQuery {
+  uint32_t id = 0;
+};
+
+struct WebGLSync {
+  uint32_t id = 0;
+};
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_WEBGL_OBJECTS_H */

package/runtime/ext_gui/webgl_pipeline.cpp

@@ -16,6 +16,7 @@
 #include <vector>
 
 #include "gui_internal.h"
+#include "perf.h"
 
 namespace xtgui {
 namespace {
@@ -251,10 +252,8 @@ SDL_GPUBuffer *WebGLContext::upload_temp_buffer(const void *data, uint32_t size,
 }
 
 SDL_GPUGraphicsPipeline *WebGLContext::create_pipeline(
-    WebGLProgram *program, int mode, int index_size, int attribute_count, int buffer_count,
-    const SDL_GPUVertexAttribute *attrs, const SDL_GPUVertexBufferDescription *buffers,
-    const std::string &key) {
-  (void)index_size;
+    WebGLProgram *program, int mode, int attribute_count, int buffer_count,
+    const SDL_GPUVertexAttribute *attrs, const SDL_GPUVertexBufferDescription *buffers) {
   SDL_GPUColorTargetDescription color_targets[kWebGLMaxDrawBuffers];
   const int color_target_count =
       state_.color_target_count > 0 ? state_.color_target_count : 1;
@@ -318,9 +317,10 @@ SDL_GPUGraphicsPipeline *WebGLContext::create_pipeline(
     set_error(GL_INVALID_OPERATION);
     return nullptr;
   }
-  program->pipeline_cache[key] = pipeline;
-  program->pipelines.push_back(pipeline);
-  return pipeline;
-}
+  /* Ownership stays with the caller: a program draw pushes the pipeline into
+   * its own list, an internal helper draw keeps it in the context. Releasing
+   * both would free it twice. */
+  g_perf_frame.webglPipelineMisses += 1;
+  return pipeline;}
 
 }  // namespace xtgui

package/runtime/ext_gui/webgl_program_internal.h

@@ -10,6 +10,41 @@
 namespace xtgui {
 namespace webgl_detail {
 
+/** The GL enum reported for a GLSL uniform type (`getActiveUniform`). */
+inline 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;
+  if (type == "sampler2DShadow") return GL_SAMPLER_2D_SHADOW;
+  if (type == "samplerCubeShadow") return GL_SAMPLER_CUBE_SHADOW;
+  if (type == "sampler2DArrayShadow") return GL_SAMPLER_2D_ARRAY_SHADOW;
+  return 0;
+}
+
+/** How many consecutive attribute/varying locations a type consumes. */
+inline int location_slots(const std::string &type) {
+  if (type == "mat2") return 2;
+  if (type == "mat3") return 3;
+  if (type == "mat4") return 4;
+  return 1;
+}
+
 /** Bytes a std140 block member occupies (the whole array for an array). */
 int member_bytes(const GlslBlockMember &member);
 

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,
@@ -174,8 +146,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 +162,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;
@@ -228,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) {
@@ -289,10 +268,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 +342,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;
@@ -419,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;
@@ -436,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();