xbintsc 0.5.38 → 0.5.41

package/runtime/ext_gui/webgl_draw_setup.cpp

@@ -0,0 +1,321 @@
+/*
+ * xbintsc GUI engine — prepared WebGL draws.
+ *
+ * Every draw needs the same three things: the pipeline for the current
+ * fixed-function state, the vertex layout of the program's active attributes,
+ * and the GPU buffer handles behind them. Building that per draw was the
+ * dominant CPU cost of a multi-element scene, so it is built once per
+ * (program, layout version, state) and cached in `draw_setups_`.
+ *
+ * A setup is invalidated by bumping one of the context's state versions:
+ * `attribs_version_` for anything that changes the vertex layout (attribute
+ * pointers, enables, VAO loads), `gpu_version_` for buffer handle changes, and
+ * `framebuffer_version_` for attachment-format changes.
+ */
+
+#include "webgl.h"
+
+#include <cstring>
+#include <utility>
+#include <vector>
+
+#include "gui_internal.h"
+
+namespace xtgui {
+namespace {
+
+int components_of_type(const std::string &type) {
+  if (!type.empty() && type.back() >= '2' && type.back() <= '4') return type.back() - '0';
+  return 1;
+}
+
+int matrix_slots(const std::string &type) {
+  if (type == "mat2") return 2;
+  if (type == "mat3") return 3;
+  if (type == "mat4") return 4;
+  return 1;
+}
+
+SDL_GPUVertexElementFormat float_format(int size) {
+  switch (size) {
+    case 1:
+      return SDL_GPU_VERTEXELEMENTFORMAT_FLOAT;
+    case 2:
+      return SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
+    case 3:
+      return SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3;
+    default:
+      return SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4;
+  }
+}
+
+SDL_GPUVertexElementFormat format_of(int size, int type, bool normalized) {
+  if (size < 1 || size > 4) return SDL_GPU_VERTEXELEMENTFORMAT_INVALID;
+  if (type == GL_FLOAT) return float_format(size);
+  if (type == GL_UNSIGNED_BYTE || type == GL_BYTE) {
+    const bool is_byte = type == GL_BYTE;
+    if (size == 2) {
+      return normalized ? (is_byte ? SDL_GPU_VERTEXELEMENTFORMAT_BYTE2_NORM
+                                   : SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2_NORM)
+                        : (is_byte ? SDL_GPU_VERTEXELEMENTFORMAT_BYTE2
+                                   : SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2);
+    }
+    if (size == 4) {
+      return normalized ? (is_byte ? SDL_GPU_VERTEXELEMENTFORMAT_BYTE4_NORM
+                                   : SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM)
+                        : (is_byte ? SDL_GPU_VERTEXELEMENTFORMAT_BYTE4
+                                   : SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4);
+    }
+    return SDL_GPU_VERTEXELEMENTFORMAT_INVALID;
+  }
+  if (type == GL_UNSIGNED_SHORT || type == GL_SHORT) {
+    const bool is_short = type == GL_SHORT;
+    if (size == 2) {
+      return normalized ? (is_short ? SDL_GPU_VERTEXELEMENTFORMAT_SHORT2_NORM
+                                    : SDL_GPU_VERTEXELEMENTFORMAT_USHORT2_NORM)
+                        : (is_short ? SDL_GPU_VERTEXELEMENTFORMAT_SHORT2
+                                    : SDL_GPU_VERTEXELEMENTFORMAT_USHORT2);
+    }
+    if (size == 4) {
+      return normalized ? (is_short ? SDL_GPU_VERTEXELEMENTFORMAT_SHORT4_NORM
+                                    : SDL_GPU_VERTEXELEMENTFORMAT_USHORT4_NORM)
+                        : (is_short ? SDL_GPU_VERTEXELEMENTFORMAT_SHORT4
+                                    : SDL_GPU_VERTEXELEMENTFORMAT_USHORT4);
+    }
+    return SDL_GPU_VERTEXELEMENTFORMAT_INVALID;
+  }
+  return SDL_GPU_VERTEXELEMENTFORMAT_INVALID;
+}
+
+SDL_GPUVertexElementFormat int_format_of(int size, int type) {
+  if (size < 1 || size > 4) return SDL_GPU_VERTEXELEMENTFORMAT_INVALID;
+  if (type == GL_INT) {
+    switch (size) {
+      case 1:
+        return SDL_GPU_VERTEXELEMENTFORMAT_INT;
+      case 2:
+        return SDL_GPU_VERTEXELEMENTFORMAT_INT2;
+      case 3:
+        return SDL_GPU_VERTEXELEMENTFORMAT_INT3;
+      default:
+        return SDL_GPU_VERTEXELEMENTFORMAT_INT4;
+    }
+  }
+  if (type == GL_UNSIGNED_INT) {
+    switch (size) {
+      case 1:
+        return SDL_GPU_VERTEXELEMENTFORMAT_UINT;
+      case 2:
+        return SDL_GPU_VERTEXELEMENTFORMAT_UINT2;
+      case 3:
+        return SDL_GPU_VERTEXELEMENTFORMAT_UINT3;
+      default:
+        return SDL_GPU_VERTEXELEMENTFORMAT_UINT4;
+    }
+  }
+  if (type == GL_SHORT && (size == 2 || size == 4)) {
+    return size == 2 ? SDL_GPU_VERTEXELEMENTFORMAT_SHORT2 : SDL_GPU_VERTEXELEMENTFORMAT_SHORT4;
+  }
+  if (type == GL_UNSIGNED_SHORT && (size == 2 || size == 4)) {
+    return size == 2 ? SDL_GPU_VERTEXELEMENTFORMAT_USHORT2
+                     : SDL_GPU_VERTEXELEMENTFORMAT_USHORT4;
+  }
+  if (type == GL_BYTE && (size == 2 || size == 4)) {
+    return size == 2 ? SDL_GPU_VERTEXELEMENTFORMAT_BYTE2 : SDL_GPU_VERTEXELEMENTFORMAT_BYTE4;
+  }
+  if (type == GL_UNSIGNED_BYTE && (size == 2 || size == 4)) {
+    return size == 2 ? SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2 : SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4;
+  }
+  return SDL_GPU_VERTEXELEMENTFORMAT_INVALID;
+}
+
+int type_size(int type) {
+  switch (type) {
+    case GL_BYTE:
+    case GL_UNSIGNED_BYTE:
+      return 1;
+    case GL_SHORT:
+    case GL_UNSIGNED_SHORT:
+      return 2;
+    default:
+      return 4;
+  }
+}
+
+}  // namespace
+
+void WebGLContext::draw_state_hash(uint64_t *first, uint64_t *second) const {
+  uint64_t h1 = 1469598103934665603ull;
+  uint64_t h2 = 0x9e3779b97f4a7c15ull;
+  auto mix = [&h1, &h2](uint64_t value) {
+    h1 ^= value;
+    h1 *= 1099511628211ull;
+    h1 ^= h1 >> 32;
+    h2 += value + 0x9e3779b97f4a7c15ull;
+    h2 = (h2 << 27) | (h2 >> 37);
+    h2 *= 0xbf58476d1ce4e5b9ull;
+  };
+  auto mix_face = [&mix](const WebGLStencilFace &face) {
+    /* `ref` is a per-pass dynamic value, not part of the pipeline. */
+    mix((uint64_t)(uint32_t)face.func);
+    mix(face.value_mask);
+    mix(face.write_mask);
+    mix((uint64_t)(uint32_t)face.fail);
+    mix((uint64_t)(uint32_t)face.zfail);
+    mix((uint64_t)(uint32_t)face.zpass);
+  };
+
+  mix(state_.blend ? 1u : 0u);
+  mix((uint64_t)(uint32_t)state_.blend_src_rgb);
+  mix((uint64_t)(uint32_t)state_.blend_dst_rgb);
+  mix((uint64_t)(uint32_t)state_.blend_src_alpha);
+  mix((uint64_t)(uint32_t)state_.blend_dst_alpha);
+  mix((uint64_t)(uint32_t)state_.blend_eq_rgb);
+  mix((uint64_t)(uint32_t)state_.blend_eq_alpha);
+  mix(state_.depth_test ? 1u : 0u);
+  mix(state_.depth_write ? 1u : 0u);
+  mix((uint64_t)(uint32_t)state_.depth_func);
+  mix(state_.stencil ? 1u : 0u);
+  mix_face(state_.stencil_front);
+  mix_face(state_.stencil_back);
+  mix(state_.cull ? 1u : 0u);
+  mix((uint64_t)(uint32_t)state_.cull_face);
+  mix((uint64_t)(uint32_t)state_.front_face);
+  for (bool channel : state_.color_mask) mix(channel ? 1u : 0u);
+  mix((uint64_t)(uint32_t)state_.color_target_count);
+  for (int i = 0; i < state_.color_target_count; i++) {
+    mix((uint64_t)(uint32_t)state_.color_formats[i]);
+  }
+  mix((uint64_t)(uint32_t)state_.depth_format);
+
+  *first = h1;
+  *second = h2;
+}
+
+void WebGLContext::clear_draw_cache() {
+  draw_setups_.clear();
+  last_setup_ = nullptr;
+  last_pipeline_ = nullptr;
+  last_setup_pass_ = 0;
+}
+
+const WebGLDrawSetup *WebGLContext::prepare_draw(const WebGLDrawKey &key) {
+  auto found = draw_setups_.find(key);
+  if (found != draw_setups_.end()) return &found->second;
+  WebGLProgram *program_ = program(key.program);
+  if (program_ == nullptr) {
+    set_error(GL_INVALID_OPERATION);
+    return nullptr;
+  }
+  /* A page that cycles through many states would otherwise grow the table
+   * without bound; clearing only costs one rebuild per live state. */
+  if (draw_setups_.size() >= 256) clear_draw_cache();
+
+  WebGLDrawSetup setup;
+  setup.attributes.reserve(program_->draw_attribs.size());
+  setup.buffers.reserve(program_->draw_attribs.size());
+  setup.bindings.reserve(program_->draw_attribs.size());
+
+  for (const WebGLDrawAttribPlan &plan : program_->draw_attribs) {
+    if (plan.location < 0 || plan.location >= kWebGLMaxAttribs) continue;
+    WebGLAttribState &attrib = attribs_[plan.location];
+    const int slots = matrix_slots(plan.type);
+    const int type_components = components_of_type(plan.type);
+    const int components = slots > 1 ? slots : (type_components > 4 ? 4 : type_components);
+    const uint32_t slot = (uint32_t)setup.buffers.size();
+
+    SDL_GPUVertexBufferDescription description;
+    memset(&description, 0, sizeof(description));
+    description.slot = slot;
+    description.input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
+    SDL_GPUBufferBinding binding;
+    memset(&binding, 0, sizeof(binding));
+
+    if (!attrib.enabled) {
+      /* A disabled attribute is a constant read from a persistent 16-byte
+       * buffer, not a fresh GPU allocation per draw. */
+      SDL_GPUBuffer *constant = constant_attrib_buffer(plan.location);
+      if (constant == nullptr) return nullptr;
+      binding.buffer = constant;
+      description.pitch = 0;
+      for (int column = 0; column < slots; column++) {
+        SDL_GPUVertexAttribute attribute;
+        memset(&attribute, 0, sizeof(attribute));
+        attribute.location = (Uint32)(plan.location + column);
+        attribute.buffer_slot = slot;
+        attribute.format = float_format(components);
+        attribute.offset = 0;
+        setup.attributes.push_back(attribute);
+      }
+      setup.buffers.push_back(description);
+      setup.bindings.push_back(binding);
+      continue;
+    }
+
+    WebGLBuffer *buffer_ = buffer(attrib.buffer);
+    if (buffer_ == nullptr || buffer_->data.empty()) {
+      set_error(GL_INVALID_OPERATION);
+      return nullptr;
+    }
+    SDL_GPUVertexElementFormat format = attrib.integer
+                                            ? int_format_of(attrib.size, attrib.type)
+                                            : format_of(attrib.size, attrib.type, attrib.normalized);
+    if (format == SDL_GPU_VERTEXELEMENTFORMAT_INVALID) {
+      set_error(GL_INVALID_OPERATION);
+      return nullptr;
+    }
+    description.input_rate = attrib.divisor > 0 ? SDL_GPU_VERTEXINPUTRATE_INSTANCE
+                                                : SDL_GPU_VERTEXINPUTRATE_VERTEX;
+    const int stride =
+        attrib.stride > 0 ? attrib.stride : components * type_size(attrib.type) * slots;
+    description.pitch = (Uint32)stride;
+    SDL_GPUBuffer *gpu = ensure_buffer_gpu(buffer_);
+    if (gpu == nullptr) return nullptr;
+    binding.buffer = gpu;
+    for (int column = 0; column < slots; column++) {
+      SDL_GPUVertexAttribute attribute;
+      memset(&attribute, 0, sizeof(attribute));
+      attribute.location = (Uint32)(plan.location + column);
+      attribute.buffer_slot = slot;
+      attribute.format = format;
+      attribute.offset = (Uint32)(attrib.offset + column * components * type_size(attrib.type));
+      setup.attributes.push_back(attribute);
+    }
+    setup.buffers.push_back(description);
+    setup.bindings.push_back(binding);
+  }
+
+  if (key.index_size > 0 && key.element_buffer != 0) {
+    WebGLBuffer *element = buffer(key.element_buffer);
+    if (element == nullptr || element->data.empty()) {
+      set_error(GL_INVALID_OPERATION);
+      return nullptr;
+    }
+    setup.index_buffer = ensure_buffer_gpu(element);
+    if (setup.index_buffer == nullptr) return nullptr;
+  }
+
+  /* The pipeline depends on the vertex layout and fixed-function state, not on
+   * which GPU buffer happens to hold the data (a buffer can be recreated after
+   * a grow) nor on the element-buffer binding. Normalise those fields out so a
+   * dynamic buffer does not create a fresh pipeline. */
+  WebGLDrawKey pipeline_key = key;
+  pipeline_key.gpu_version = 0;
+  pipeline_key.element_buffer = 0;
+  auto cached = program_->pipeline_cache.find(pipeline_key);
+  if (cached != program_->pipeline_cache.end()) {
+    setup.pipeline = cached->second;
+  } else {
+    setup.pipeline = create_pipeline(program_, key.mode, (int)setup.attributes.size(),
+                                     (int)setup.buffers.size(), setup.attributes.data(),
+                                     setup.buffers.data());
+    if (setup.pipeline == nullptr) return nullptr;
+    program_->pipeline_cache[pipeline_key] = setup.pipeline;
+    program_->pipelines.push_back(setup.pipeline);
+  }
+
+  auto inserted = draw_setups_.emplace(key, std::move(setup));
+  return &inserted.first->second;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_draw_state.h

@@ -0,0 +1,130 @@
+/*
+ * xbintsc GUI engine — the fixed-function WebGL state a pipeline depends on.
+ *
+ * Split out of `webgl.h` to keep that header under the repository's
+ * file-length budget.
+ */
+#ifndef XT_GUI_WEBGL_DRAW_STATE_H
+#define XT_GUI_WEBGL_DRAW_STATE_H
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include <SDL3/SDL.h>
+
+#include "webgl_constants.h"
+
+namespace xtgui {
+
+/** One face's stencil test and update state. */
+struct WebGLStencilFace {
+  int func = GL_ALWAYS;
+  int ref = 0;
+  uint32_t value_mask = 0xFFFFFFFFu;  // compare mask
+  uint32_t write_mask = 0xFFFFFFFFu;
+  int fail = GL_KEEP;
+  int zfail = GL_KEEP;
+  int zpass = GL_KEEP;
+};
+
+/** The fixed-function state a pipeline depends on. */
+struct WebGLDrawState {
+  bool blend = false;
+  int blend_src_rgb = GL_ONE;
+  int blend_dst_rgb = GL_ZERO;
+  int blend_src_alpha = GL_ONE;
+  int blend_dst_alpha = GL_ZERO;
+  int blend_eq_rgb = GL_FUNC_ADD;
+  int blend_eq_alpha = GL_FUNC_ADD;
+  bool depth_test = false;
+  bool depth_write = true;
+  int depth_func = GL_LESS;
+  bool stencil = false;
+  WebGLStencilFace stencil_front;
+  WebGLStencilFace stencil_back;
+  bool cull = false;
+  int cull_face = GL_BACK;
+  int front_face = GL_CCW;
+  bool color_mask[4] = {true, true, true, true};
+  /** Attachment formats of the bound target; pipelines are format-specific. */
+  int color_formats[4] = {
+      SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM,
+      SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM};
+  int color_target_count = 1;
+  int depth_format = SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
+};
+
+/**
+ * Identity of one prepared draw. Everything a draw's pipeline, vertex layout
+ * and GPU buffer handles depend on is either an exact integer here or folds
+ * into `state_hash`/`state_hash2` (a 128-bit hash of `WebGLDrawState`). Two
+ * independent hashes keep a collision in the same place a 128-bit hash would
+ * have it — the state struct has no padding-sensitive fields to compare.
+ */
+struct WebGLDrawKey {
+  uint32_t program = 0;
+  int mode = 0;                // GL primitive mode
+  int index_size = 0;          // 0 = drawArrays, otherwise index element bytes
+  uint32_t element_buffer = 0; // bound GL_ELEMENT_ARRAY_BUFFER, 0 = none
+  uint64_t attribs_version = 0;
+  uint64_t gpu_version = 0;
+  uint64_t framebuffer_version = 0;
+  uint64_t state_hash = 0;
+  uint64_t state_hash2 = 0;
+
+  bool operator==(const WebGLDrawKey &other) const {
+    return program == other.program && mode == other.mode && index_size == other.index_size &&
+           element_buffer == other.element_buffer && attribs_version == other.attribs_version &&
+           gpu_version == other.gpu_version &&
+           framebuffer_version == other.framebuffer_version && state_hash == other.state_hash &&
+           state_hash2 == other.state_hash2;
+  }
+};
+
+struct WebGLDrawKeyHash {
+  size_t operator()(const WebGLDrawKey &key) const {
+    uint64_t hash = 1469598103934665603ull;
+    auto mix = [&hash](uint64_t value) {
+      hash ^= value;
+      hash *= 1099511628211ull;
+      hash ^= hash >> 29;
+    };
+    mix(key.program);
+    mix((uint64_t)(uint32_t)key.mode);
+    mix((uint64_t)(uint32_t)key.index_size);
+    mix(key.element_buffer);
+    mix(key.attribs_version);
+    mix(key.gpu_version);
+    mix(key.framebuffer_version);
+    mix(key.state_hash);
+    mix(key.state_hash2);
+    return (size_t)hash;
+  }
+};
+
+/**
+ * One active vertex attribute, resolved once at link time: `location` is the
+ * base attribute location and `type` the GLSL type name the draw needs to size
+ * the vertex layout. Keeping this out of the draw path removes the per-draw
+ * `attribs` scan and the `name -> location` string hash lookup.
+ */
+struct WebGLDrawAttribPlan {
+  int location = -1;
+  std::string type;
+};
+
+/** A pipeline and the vertex-layout/binding set the draw prepared for it. A
+ * cache hit is a bind (when it changed) and a draw. */
+struct WebGLDrawSetup {
+  SDL_GPUGraphicsPipeline *pipeline = nullptr;
+  std::vector<SDL_GPUVertexAttribute> attributes;
+  std::vector<SDL_GPUVertexBufferDescription> buffers;
+  std::vector<SDL_GPUBufferBinding> bindings;
+  SDL_GPUBuffer *index_buffer = nullptr;
+};
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_WEBGL_DRAW_STATE_H */

package/runtime/ext_gui/webgl_glsl_scan.cpp

@@ -425,14 +425,9 @@ 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;
-    }
+    /* `gl_FragDepth`/`gl_FragDepthEXT`: the Vulkan SPIR-V path emits
+     * `DepthReplacing`, and SPIRV-Cross turns that into `[[depth(any)]]` for
+     * Metal, so a fragment shader may write the depth attachment directly. */
     /* 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. */

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