xbintsc 0.5.37 → 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.h

@@ -126,6 +126,9 @@ struct GlslLinkLayout {
   std::vector<GlslUniformDecl> block_members;
 };
 
+/** Expand three.js's `#pragma unroll_loop_start` loops into constant indices. */
+std::string unroll_glsl_pragmas(const std::string &source);
+
 /** Scan `source` for the declarations WebGL needs to know about. */
 void scan_glsl(const std::string &source, bool fragment, GlslShaderInfo *info);
 

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. */