xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/webgl_draw_buffers.cpp

@@ -0,0 +1,75 @@
+/*
+ * xbintsc GUI engine — WebGL 2 draw/read buffers and multiple render targets.
+ *
+ * The framebuffer stores up to four colour attachments and the draw-buffer
+ * table that maps pipeline slot N to one of them. `begin_pass` and
+ * `create_pipeline` consume the same slots, so a fragment shader's `out`
+ * variables land in the attachments the page selected with `drawBuffers`.
+ */
+
+#include "webgl.h"
+
+#include "gui_internal.h"
+
+namespace xtgui {
+
+SDL_GPUTexture *WebGLContext::draw_color_texture(int slot) {
+  if (slot < 0 || slot >= kWebGLMaxDrawBuffers) return nullptr;
+  if (bound_framebuffer_ == 0) {
+    ensure_default_target();
+    return slot == 0 && default_draw_buffers_[0] == GL_BACK ? color_ : nullptr;
+  }
+  WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
+  if (framebuffer == nullptr) return nullptr;
+  const int buffer = framebuffer->draw_buffers[slot];
+  const int index = buffer - GL_COLOR_ATTACHMENT0;
+  if (index < 0 || index >= kWebGLMaxDrawBuffers) return nullptr;
+  if (framebuffer->color_textures[index] == 0) return nullptr;
+  WebGLTexture *texture = this->texture(framebuffer->color_textures[index]);
+  return texture != nullptr ? ensure_texture_gpu(texture, true) : nullptr;
+}
+
+int WebGLContext::draw_color_format(int slot) {
+  if (bound_framebuffer_ == 0) return SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
+  if (framebuffer == nullptr) return SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  const int index = framebuffer->draw_buffers[slot] - GL_COLOR_ATTACHMENT0;
+  if (index < 0 || index >= kWebGLMaxDrawBuffers) {
+    return SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  }
+  WebGLTexture *texture = this->texture(framebuffer->color_textures[index]);
+  return texture != nullptr ? (int)texture->format : SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+}
+
+int WebGLContext::draw_color_layer(int slot) {
+  if (slot < 0 || slot >= kWebGLMaxDrawBuffers || bound_framebuffer_ == 0) return 0;
+  WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
+  if (framebuffer == nullptr) return 0;
+  const int index = framebuffer->draw_buffers[slot] - GL_COLOR_ATTACHMENT0;
+  if (index < 0 || index >= kWebGLMaxDrawBuffers) return 0;
+  return framebuffer->color_layers[index];
+}
+
+void WebGLContext::draw_buffers(int count, const int *buffers) {
+  if (count < 0) count = 0;
+  if (count > kWebGLMaxDrawBuffers) count = kWebGLMaxDrawBuffers;
+  int *target = default_draw_buffers_;
+  if (bound_framebuffer_ != 0) {
+    WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
+    if (framebuffer == nullptr) return;
+    target = framebuffer->draw_buffers;
+  }
+  for (int i = 0; i < kWebGLMaxDrawBuffers; i++) {
+    target[i] = (i < count && buffers != nullptr) ? buffers[i] : GL_NONE;
+  }
+  end_pass();
+}
+
+int WebGLContext::draw_buffer_value(int index) {
+  if (index < 0 || index >= kWebGLMaxDrawBuffers) return GL_NONE;
+  if (bound_framebuffer_ == 0) return default_draw_buffers_[index];
+  WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
+  return framebuffer != nullptr ? framebuffer->draw_buffers[index] : GL_NONE;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_glsl.h

@@ -22,6 +22,8 @@
 
 #include <cstdint>
 #include <string>
+
+#include "webgl_glsl_tokens.h"
 #include <unordered_map>
 #include <utility>
 #include <vector>
@@ -40,6 +42,32 @@ struct GlslUniformDecl {
   std::string extra;
 };
 
+/** One member of a user-declared uniform block. */
+struct GlslBlockMemberDecl {
+  std::string type;
+  std::string name;
+  std::string array;
+};
+
+/** A user-declared `uniform Block { … } instance;`. The rewriter merges its
+ * members into the engine block under `__ub_<instance>_<member>` names and
+ * rewrites references, because SDL_GPU has no bindable uniform buffers. */
+struct GlslUniformBlock {
+  std::string name;
+  std::string instance;
+  std::vector<GlslBlockMemberDecl> members;
+  size_t begin = 0;
+  size_t end = 0;
+  bool conditional = false;
+};
+
+/** One `instance.member` reference to rename. */
+struct GlslRename {
+  size_t begin = 0;
+  size_t end = 0;
+  std::string text;
+};
+
 /** Where one declaration sits in the source text, and what it declares. */
 struct GlslDeclSite {
   enum Kind { Uniform, Sampler, Attribute, Varying, FragmentOut };
@@ -53,6 +81,14 @@ struct GlslDeclSite {
 };
 
 /** The declarations a shader contributes to a program. */
+struct GlslShaderInfo;
+
+/** Parse a user uniform block at `uniform_index`, merging its members. Returns
+ * true when a block declaration was consumed; `after` is the next token. */
+bool scan_uniform_block(const std::vector<GlslToken> &tokens, size_t uniform_index,
+                        size_t pending_layout, bool conditional, GlslShaderInfo *info,
+                        size_t *after, size_t *first_uniform_any);
+
 struct GlslShaderInfo {
   std::vector<GlslUniformDecl> uniforms;   // non-sampler
   std::vector<GlslUniformDecl> samplers;
@@ -65,6 +101,10 @@ struct GlslShaderInfo {
   std::vector<std::pair<size_t, size_t>> structs;
   /** The text of those definitions, shared across stages at link time. */
   std::vector<std::string> struct_definitions;
+  /** User uniform blocks, merged into the single engine block at link time. */
+  std::vector<GlslUniformBlock> blocks;
+  /** References the rewriter must spell with the prefixed member name. */
+  std::vector<GlslRename> renames;
   /** True when the source writes `gl_FragColor` / `gl_FragData[0]`. */
   bool legacy_fragment_output = false;
   /** True when the source declared its own `out` variable (ES 3.00). */

package/runtime/ext_gui/webgl_glsl_compile.cpp

@@ -10,6 +10,8 @@
 
 #include "webgl_glsl.h"
 
+#include <cstdio>
+#include <cstdlib>
 #include <cstring>
 #include <string>
 #include <unordered_map>
@@ -347,6 +349,10 @@ bool compile_glsl(const std::string &source, bool fragment, std::vector<uint32_t
   }
   const EShLanguage stage = fragment ? EShLangFragment : EShLangVertex;
   glslang::TShader shader(stage);
+  if (getenv("XT_WEBGL_DUMP_GLSL") != nullptr) {
+    fprintf(stderr, "--- GLSL %s ---\n%s\n---\n", fragment ? "fragment" : "vertex",
+            source.c_str());
+  }
   const char *text = source.c_str();
   shader.setStrings(&text, 1);
   shader.setEntryPoint("main");

package/runtime/ext_gui/webgl_glsl_rewrite.cpp

@@ -213,6 +213,24 @@ std::string rewrite_glsl(const std::string &source, bool fragment, const GlslLin
     edits.push_back(block_edit);
   }
 
+  /* Drop user uniform-block declarations (their members are already part of
+   * the generated block) and spell `instance.member` with the prefixed name. */
+  for (const GlslUniformBlock &block_decl : info.blocks) {
+    Edit remove;
+    remove.begin = block_decl.begin;
+    remove.end = block_decl.end;
+    remove.order = 1;
+    edits.push_back(remove);
+  }
+  for (const GlslRename &rename : info.renames) {
+    Edit edit;
+    edit.begin = rename.begin;
+    edit.end = rename.end;
+    edit.text = rename.text;
+    edit.order = 1;
+    edits.push_back(edit);
+  }
+
   int fragment_output = 0;
   for (const GlslDeclSite &site : info.sites) {
     Edit edit;

package/runtime/ext_gui/webgl_glsl_scan.cpp

@@ -17,12 +17,7 @@
 namespace xtgui {
 namespace {
 
-struct Token {
-  enum Kind { Ident, Number, Punct, Directive } kind = Punct;
-  std::string text;
-  size_t begin = 0;
-  size_t end = 0;
-};
+using Token = GlslToken;
 
 bool is_ident_start(char c) {
   return std::isalpha((unsigned char)c) != 0 || c == '_';
@@ -100,11 +95,6 @@ std::vector<Token> tokenize(const std::string &source) {
   return tokens;
 }
 
-bool is_qualifier(const std::string &text) {
-  return text == "highp" || text == "mediump" || text == "lowp" || text == "flat" ||
-         text == "smooth" || text == "centroid" || text == "invariant" || text == "precise" ||
-         text == "noperspective" || text == "sample" || text == "const";
-}
 
 bool is_sampler_type(const std::string &type) {
   return type.rfind("sampler", 0) == 0 || type == "atomic_uint";
@@ -435,6 +425,14 @@ void scan_glsl(const std::string &source, bool fragment, GlslShaderInfo *info) {
       info->legacy_fragment_output = true;
       continue;
     }
+    /* SDL_GPU render targets carry no writable depth attachment, so there is
+     * no place for a shader-written depth value; reject it with a clear log
+     * instead of failing later inside glslang. */
+    if (inactive == 0 && fragment && token.kind == Token::Ident &&
+        (token.text == "gl_FragDepth" || token.text == "gl_FragDepthEXT")) {
+      info->unsupported = "gl_FragDepth is not supported";
+      continue;
+    }
     /* Declarations inside a definitively false preprocessor branch never reach
      * the compiler; rewriting them would move their types/macros (and array
      * sizes such as `MORPHTARGETS_COUNT`) outside that branch. */
@@ -503,6 +501,17 @@ void scan_glsl(const std::string &source, bool fragment, GlslShaderInfo *info) {
       continue;
     }
 
+    if (kind == GlslDeclSite::Uniform) {
+      size_t after = i;
+      if (scan_uniform_block(tokens, i, pending_layout, !condition_stack.empty(), info, &after,
+                             &first_uniform_any)) {
+        pending_layout = std::string::npos;
+        pending_location = -1;
+        i = after;
+        continue;
+      }
+    }
+
     /* Find the terminating semicolon at bracket/paren depth 0. */
     size_t semicolon = i + 1;
     int brackets = 0;

package/runtime/ext_gui/webgl_glsl_scan_block.cpp

@@ -0,0 +1,126 @@
+/*
+ * xbintsc GUI engine — GLSL user uniform-block scanner.
+ *
+ * The block's members are merged into the engine's single std140 block under
+ * `xt_ub_<instance>_<member>` names; `instance.member` references are renamed
+ * by the rewriter. SDL_GPU has no bindable uniform buffers, so the draw path
+ * copies the bound buffer into these members instead.
+ */
+
+#include "webgl_glsl.h"
+
+#include <string>
+#include <vector>
+
+namespace xtgui {
+
+bool scan_uniform_block(const std::vector<GlslToken> &tokens, size_t uniform_index,
+                        size_t pending_layout, bool conditional, GlslShaderInfo *info,
+                        size_t *after, size_t *first_uniform_any) {
+  size_t brace = uniform_index + 1;
+  while (brace < tokens.size() && tokens[brace].text != "{" && tokens[brace].text != ";") {
+    brace++;
+  }
+  if (brace >= tokens.size() || tokens[brace].text != "{") return false;
+
+  std::string block_name;
+  for (size_t t = uniform_index + 1; t < brace; t++) {
+    if (tokens[t].kind == GlslToken::Ident) block_name = tokens[t].text;
+  }
+  size_t close = brace;
+  int braces = 0;
+  for (; close < tokens.size(); close++) {
+    if (tokens[close].text == "{") braces++;
+    if (tokens[close].text == "}") {
+      braces--;
+      if (braces == 0) break;
+    }
+    if (tokens[close].kind == GlslToken::Directive) {
+      info->unsupported = "preprocessor directives inside uniform blocks are not supported";
+      *after = close;
+      return true;
+    }
+  }
+  if (close + 2 >= tokens.size() || tokens[close + 1].kind != GlslToken::Ident ||
+      tokens[close + 2].text != ";") {
+    info->unsupported = "uniform blocks without an instance name are not supported";
+    *after = close;
+    return true;
+  }
+
+  GlslUniformBlock block;
+  block.name = block_name;
+  block.instance = tokens[close + 1].text;
+  block.begin = pending_layout != std::string::npos ? tokens[pending_layout].begin
+                                                    : tokens[uniform_index].begin;
+  block.end = tokens[close + 2].end;
+  block.conditional = conditional;
+  bool valid = !block.instance.empty();
+  size_t member_start = brace + 1;
+  int inner_braces = 0;
+  for (size_t t = brace + 1; t < close && valid; t++) {
+    if (tokens[t].text == "{") inner_braces++;
+    if (tokens[t].text == "}") inner_braces--;
+    if (!(tokens[t].text == ";" && inner_braces == 0)) continue;
+    size_t at = member_start;
+    while (at < t && tokens[at].kind == GlslToken::Ident && is_qualifier(tokens[at].text)) at++;
+    if (at + 1 >= t || tokens[at].kind != GlslToken::Ident ||
+        tokens[at + 1].kind != GlslToken::Ident) {
+      valid = false;
+      break;
+    }
+    GlslBlockMemberDecl member;
+    member.type = tokens[at].text;
+    member.name = tokens[at + 1].text;
+    size_t array_at = at + 2;
+    if (array_at < t && tokens[array_at].text == "[") {
+      std::string array;
+      for (size_t k = array_at; k < t; k++) array += tokens[k].text;
+      member.array = array;
+    }
+    if (member.type.rfind("sampler", 0) == 0 || member.type == "atomic_uint" ||
+        member.type == "struct") {
+      valid = false;
+      break;
+    }
+    block.members.push_back(member);
+    member_start = t + 1;
+  }
+  if (!valid || block.members.empty()) {
+    info->unsupported = "unsupported uniform block declaration";
+    *after = close;
+    return true;
+  }
+
+  for (size_t t = 0; t + 2 < tokens.size(); t++) {
+    if (tokens[t].kind != GlslToken::Ident || tokens[t].text != block.instance) continue;
+    if (tokens[t + 1].text != "." || tokens[t + 2].kind != GlslToken::Ident) continue;
+    if (tokens[t].begin >= block.begin && tokens[t].begin < block.end) continue;
+    bool is_member = false;
+    for (const GlslBlockMemberDecl &member : block.members) {
+      if (member.name == tokens[t + 2].text) is_member = true;
+    }
+    if (!is_member) continue;
+    GlslRename rename;
+    rename.begin = tokens[t].begin;
+    rename.end = tokens[t + 2].end;
+    rename.text = "xt_ub_" + block.instance + "_" + tokens[t + 2].text;
+    info->renames.push_back(rename);
+  }
+  for (const GlslBlockMemberDecl &member : block.members) {
+    GlslUniformDecl decl;
+    decl.type = member.type;
+    decl.name = "xt_ub_" + block.instance + "_" + member.name;
+    decl.array = member.array;
+    info->uniforms.push_back(decl);
+  }
+  if (*first_uniform_any == std::string::npos) *first_uniform_any = block.begin;
+  if (!block.conditional && info->first_uniform_offset == std::string::npos) {
+    info->first_uniform_offset = block.begin;
+  }
+  info->blocks.push_back(block);
+  *after = close + 2;
+  return true;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_glsl_tokens.h

@@ -0,0 +1,28 @@
+/*
+ * xbintsc GUI engine — shared GLSL token type for the scanner and block parser.
+ */
+#ifndef XT_GUI_WEBGL_GLSL_TOKENS_H
+#define XT_GUI_WEBGL_GLSL_TOKENS_H
+
+#include <cstddef>
+#include <string>
+
+namespace xtgui {
+
+struct GlslToken {
+  enum Kind { Ident, Number, Punct, Directive } kind = Punct;
+  std::string text;
+  size_t begin = 0;
+  size_t end = 0;
+};
+
+inline bool is_qualifier(const std::string &text) {
+  return text == "const" || text == "uniform" || text == "attribute" || text == "varying" ||
+         text == "in" || text == "out" || text == "inout" || text == "highp" ||
+         text == "mediump" || text == "lowp" || text == "flat" || text == "smooth" ||
+         text == "centroid" || text == "invariant" || text == "precision";
+}
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_WEBGL_GLSL_TOKENS_H */

package/runtime/ext_gui/webgl_pipeline.cpp

@@ -87,6 +87,46 @@ SDL_GPUCompareOp compare_op(int func) {
   }
 }
 
+SDL_GPUStencilOp stencil_op(int op) {
+  switch (op) {
+    case GL_ZERO:
+      return SDL_GPU_STENCILOP_ZERO;
+    case GL_REPLACE:
+      return SDL_GPU_STENCILOP_REPLACE;
+    case GL_INCR:
+      return SDL_GPU_STENCILOP_INCREMENT_AND_CLAMP;
+    case GL_INCR_WRAP:
+      return SDL_GPU_STENCILOP_INCREMENT_AND_WRAP;
+    case GL_DECR:
+      return SDL_GPU_STENCILOP_DECREMENT_AND_CLAMP;
+    case GL_DECR_WRAP:
+      return SDL_GPU_STENCILOP_DECREMENT_AND_WRAP;
+    case GL_INVERT:
+      return SDL_GPU_STENCILOP_INVERT;
+    default:
+      return SDL_GPU_STENCILOP_KEEP;
+  }
+}
+
+/** SDL 3.2 has no per-pipeline stencil write mask. A mask of 0 means "write
+ * nothing", which every op can express as KEEP; a partial mask cannot be
+ * represented, so the op applies to all bits. */
+SDL_GPUStencilOpState stencil_face_state(const WebGLStencilFace &face) {
+  SDL_GPUStencilOpState state;
+  memset(&state, 0, sizeof(state));
+  if (face.write_mask == 0) {
+    state.fail_op = SDL_GPU_STENCILOP_KEEP;
+    state.pass_op = SDL_GPU_STENCILOP_KEEP;
+    state.depth_fail_op = SDL_GPU_STENCILOP_KEEP;
+  } else {
+    state.fail_op = stencil_op(face.fail);
+    state.pass_op = stencil_op(face.zpass);
+    state.depth_fail_op = stencil_op(face.zfail);
+  }
+  state.compare_op = compare_op(face.func);
+  return state;
+}
+
 SDL_GPUPrimitiveType primitive_of(int mode) {
   switch (mode) {
     case GL_POINTS:
@@ -215,22 +255,27 @@ SDL_GPUGraphicsPipeline *WebGLContext::create_pipeline(
     const SDL_GPUVertexAttribute *attrs, const SDL_GPUVertexBufferDescription *buffers,
     const std::string &key) {
   (void)index_size;
-  SDL_GPUColorTargetDescription color_target;
-  memset(&color_target, 0, sizeof(color_target));
-  color_target.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
-  color_target.blend_state.enable_blend = state_.blend;
-  color_target.blend_state.src_color_blendfactor = blend_factor(state_.blend_src_rgb);
-  color_target.blend_state.dst_color_blendfactor = blend_factor(state_.blend_dst_rgb);
-  color_target.blend_state.color_blend_op = blend_op(state_.blend_eq_rgb);
-  color_target.blend_state.src_alpha_blendfactor = blend_factor(state_.blend_src_alpha);
-  color_target.blend_state.dst_alpha_blendfactor = blend_factor(state_.blend_dst_alpha);
-  color_target.blend_state.alpha_blend_op = blend_op(state_.blend_eq_alpha);
-  color_target.blend_state.enable_color_write_mask = true;
-  color_target.blend_state.color_write_mask =
-      (state_.color_mask[0] ? SDL_GPU_COLORCOMPONENT_R : 0) |
-      (state_.color_mask[1] ? SDL_GPU_COLORCOMPONENT_G : 0) |
-      (state_.color_mask[2] ? SDL_GPU_COLORCOMPONENT_B : 0) |
-      (state_.color_mask[3] ? SDL_GPU_COLORCOMPONENT_A : 0);
+  SDL_GPUColorTargetDescription color_targets[kWebGLMaxDrawBuffers];
+  const int color_target_count =
+      state_.color_target_count > 0 ? state_.color_target_count : 1;
+  for (int i = 0; i < color_target_count; i++) {
+    SDL_GPUColorTargetDescription &color_target = color_targets[i];
+    memset(&color_target, 0, sizeof(color_target));
+    color_target.format = (SDL_GPUTextureFormat)state_.color_formats[i];
+    color_target.blend_state.enable_blend = state_.blend;
+    color_target.blend_state.src_color_blendfactor = blend_factor(state_.blend_src_rgb);
+    color_target.blend_state.dst_color_blendfactor = blend_factor(state_.blend_dst_rgb);
+    color_target.blend_state.color_blend_op = blend_op(state_.blend_eq_rgb);
+    color_target.blend_state.src_alpha_blendfactor = blend_factor(state_.blend_src_alpha);
+    color_target.blend_state.dst_alpha_blendfactor = blend_factor(state_.blend_dst_alpha);
+    color_target.blend_state.alpha_blend_op = blend_op(state_.blend_eq_alpha);
+    color_target.blend_state.enable_color_write_mask = true;
+    color_target.blend_state.color_write_mask =
+        (state_.color_mask[0] ? SDL_GPU_COLORCOMPONENT_R : 0) |
+        (state_.color_mask[1] ? SDL_GPU_COLORCOMPONENT_G : 0) |
+        (state_.color_mask[2] ? SDL_GPU_COLORCOMPONENT_B : 0) |
+        (state_.color_mask[3] ? SDL_GPU_COLORCOMPONENT_A : 0);
+  }
 
   SDL_GPUGraphicsPipelineCreateInfo info;
   memset(&info, 0, sizeof(info));
@@ -255,9 +300,16 @@ SDL_GPUGraphicsPipeline *WebGLContext::create_pipeline(
   info.depth_stencil_state.enable_depth_test = state_.depth_test;
   info.depth_stencil_state.enable_depth_write = state_.depth_write;
   info.depth_stencil_state.compare_op = compare_op(state_.depth_func);
-  info.target_info.color_target_descriptions = &color_target;
-  info.target_info.num_color_targets = 1;
-  info.target_info.depth_stencil_format = SDL_GPU_TEXTUREFORMAT_D32_FLOAT;
+  info.depth_stencil_state.enable_stencil_test = state_.stencil;
+  info.depth_stencil_state.front_stencil_state = stencil_face_state(state_.stencil_front);
+  info.depth_stencil_state.back_stencil_state = stencil_face_state(state_.stencil_back);
+  /* SDL_GPU has one compare/write mask for both faces; use the front-face
+   * values (WebGL's default sets both faces alike). */
+  info.depth_stencil_state.compare_mask = (Uint8)(state_.stencil_front.value_mask & 0xFF);
+  info.depth_stencil_state.write_mask = (Uint8)(state_.stencil_front.write_mask & 0xFF);
+  info.target_info.color_target_descriptions = color_targets;
+  info.target_info.num_color_targets = (Uint32)color_target_count;
+  info.target_info.depth_stencil_format = (SDL_GPUTextureFormat)state_.depth_format;
   info.target_info.has_depth_stencil_target = true;
 
   SDL_GPUGraphicsPipeline *pipeline = SDL_CreateGPUGraphicsPipeline(guidev::g_device, &info);

package/runtime/ext_gui/webgl_program_blocks.cpp

@@ -0,0 +1,58 @@
+/*
+ * xbintsc GUI engine — user uniform blocks reflected from the merged block.
+ */
+
+#include "webgl.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "webgl_program_internal.h"
+
+namespace xtgui {
+namespace webgl_detail {
+
+void build_uniform_blocks(WebGLProgram *record, const std::vector<GlslUniformBlock> &vertex_blocks,
+                          const std::vector<GlslUniformBlock> &fragment_blocks,
+                          const std::vector<GlslBlockMember> &members) {
+  if (record == nullptr) return;
+  /* Build the user-facing uniform-block table. Members were merged into the
+   * engine block as `__ub_<instance>_<member>`, so their reflected offsets give
+   * the block's base and size without a second descriptor set. */
+  auto add_blocks = [&](const std::vector<GlslUniformBlock> &blocks) {
+    for (const GlslUniformBlock &decl : blocks) {
+      bool exists = false;
+      for (const WebGLUniformBlock &existing : record->blocks) {
+        if (existing.instance == decl.instance) exists = true;
+      }
+      if (exists) continue;
+      WebGLUniformBlock block;
+      block.name = decl.name;
+      block.instance = decl.instance;
+      int base = -1;
+      int end = 0;
+      int count = 0;
+      for (const GlslBlockMemberDecl &member : decl.members) {
+        const std::string name = "xt_ub_" + decl.instance + "_" + member.name;
+        for (const GlslBlockMember &reflected : members) {
+          if (reflected.name != name && reflected.name != name + "[0]") continue;
+          if (base < 0 || reflected.offset < base) base = reflected.offset;
+          end = std::max(end, reflected.offset + webgl_detail::member_bytes(reflected));
+          count++;
+          break;
+        }
+      }
+      if (base < 0 || count == 0) continue;
+      block.base_offset = base;
+      block.data_size = ((end - base) + 15) & ~15;
+      block.member_count = count;
+      record->blocks.push_back(block);
+    }
+  };
+  add_blocks(vertex_blocks);
+  add_blocks(fragment_blocks);
+
+}
+
+}  // namespace webgl_detail
+}  // namespace xtgui

package/runtime/ext_gui/webgl_program_internal.h

@@ -4,6 +4,7 @@
 #ifndef XT_GUI_WEBGL_PROGRAM_INTERNAL_H
 #define XT_GUI_WEBGL_PROGRAM_INTERNAL_H
 
+#include "webgl.h"
 #include "webgl_glsl.h"
 
 namespace xtgui {
@@ -12,6 +13,11 @@ namespace webgl_detail {
 /** Bytes a std140 block member occupies (the whole array for an array). */
 int member_bytes(const GlslBlockMember &member);
 
+/** Fill `record->blocks` from the user blocks merged into the engine block. */
+void build_uniform_blocks(WebGLProgram *record, const std::vector<GlslUniformBlock> &vertex_blocks,
+                          const std::vector<GlslUniformBlock> &fragment_blocks,
+                          const std::vector<GlslBlockMember> &members);
+
 }  // namespace webgl_detail
 }  // namespace xtgui
 

package/runtime/ext_gui/webgl_shader.cpp

@@ -40,6 +40,8 @@ int gl_type_of(const std::string &type) {
   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;
 }
 
@@ -380,7 +382,15 @@ bool WebGLContext::link_program(uint32_t id) {
   reflect_uniform_block(vs_spirv, &members);
   std::vector<GlslBlockMember> fragment_members;
   reflect_uniform_block(fs_spirv, &fragment_members);
-  if (members.empty()) members = 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) {
+    bool present = false;
+    for (const GlslBlockMember &existing : members) {
+      if (existing.name == member.name) present = true;
+    }
+    if (!present) members.push_back(member);
+  }
 
   record->uniforms.clear();
   record->uniform_index.clear();
@@ -445,6 +455,8 @@ bool WebGLContext::link_program(uint32_t id) {
   for (const GlslUniformDecl &decl : vs_info.samplers) add_sampler(record, &record->vs_sampler_uniforms, decl);
   for (const GlslUniformDecl &decl : fs_info.samplers) add_sampler(record, &record->fs_sampler_uniforms, decl);
 
+  webgl_detail::build_uniform_blocks(record, vs_info.blocks, fs_info.blocks, members);
+
   /* (Re)create the SDL shaders. */
   if (guidev::g_device == nullptr) {
     record->log = "no GPU device";