xbintsc 0.5.37 → 0.5.41

package/runtime/ext_gui/webgl.h

@@ -32,15 +32,13 @@
 
 #include "webgl_constants.h"
 #include "webgl2_constants.h"
+#include "webgl_draw_state.h"
 #include "webgl_glsl.h"
+#include "webgl_objects.h"
 #include "webgl_uniform_block.h"
 
 namespace xtgui {
 
-constexpr int kWebGLMaxAttribs = 16;
-constexpr int kWebGLMaxTextureUnits = 16;
-constexpr int kWebGLMaxDrawBuffers = 4;
-
 struct WebGLShader {
   uint32_t id = 0;
   int type = 0;  // GL_VERTEX_SHADER / GL_FRAGMENT_SHADER
@@ -56,6 +54,10 @@ struct WebGLUniform {
   std::string name;
   GlslBlockMember layout;
   bool sampler = false;
+  /** `sampler2DShadow`/`samplerCubeShadow`/`sampler2DArrayShadow`: SDL_GPU
+   * binds a comparison sampler, and the GLSL `texture()` call performs the
+   * hardware depth compare. */
+  bool compare = false;
   int unit = -1;
 };
 
@@ -68,6 +70,7 @@ struct WebGLProgram {
   std::vector<WebGLUniform> uniforms;
   std::vector<WebGLUniformBlock> blocks;
   std::vector<GlslUniformDecl> attribs;
+  std::vector<WebGLDrawAttribPlan> draw_attribs;
   std::unordered_map<std::string, int> attrib_locations;  // name -> location
   std::unordered_map<std::string, int> attrib_bindings;   // bindAttribLocation overrides
   std::unordered_map<std::string, int> uniform_index;     // name -> uniforms[] index
@@ -81,145 +84,7 @@ struct WebGLProgram {
   SDL_GPUShader *vs_shader = nullptr;
   SDL_GPUShader *fs_shader = nullptr;
   std::vector<SDL_GPUGraphicsPipeline *> pipelines;
-  std::unordered_map<std::string, SDL_GPUGraphicsPipeline *> pipeline_cache;
-};
-
-struct WebGLBuffer {
-  uint32_t id = 0;
-  std::vector<uint8_t> data;
-  SDL_GPUBuffer *gpu = nullptr;
-  uint32_t capacity = 0;
-  bool dirty = true;
-  /** `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;
-  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};
-};
-
-/** 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;
-  SDL_GPUSampler *gpu = nullptr;
-};
-
-struct WebGLQuery {
-  uint32_t id = 0;
-};
-
-struct WebGLSync {
-  uint32_t id = 0;
-};
-
-/** 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[kWebGLMaxDrawBuffers] = {
-      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;
+  std::unordered_map<WebGLDrawKey, SDL_GPUGraphicsPipeline *, WebGLDrawKeyHash> pipeline_cache;
 };
 
 class WebGLContext {
@@ -416,6 +281,10 @@ class WebGLContext {
   void bind_framebuffer(int target, uint32_t id);
   uint32_t bound_read_framebuffer_id() const { return read_framebuffer_; }
   bool blit_framebuffer(const int source[4], const int destination[4], int mask, int filter);
+  /** Copy the depth attachment with a sampling pass (SDL_GPU's blit only copies
+   * colour); stencil bits are not copied. */
+  bool blit_depth(uint32_t source_framebuffer, uint32_t destination_framebuffer,
+                  const int source[4], const int destination[4]);
   bool framebuffer_texture(uint32_t framebuffer, uint32_t texture,
                            int attachment = GL_COLOR_ATTACHMENT0);
   bool framebuffer_texture_layer(uint32_t framebuffer, uint32_t texture, int attachment,
@@ -476,6 +345,7 @@ class WebGLContext {
   /** The 1×1 texture a scissored colour clear blits from. */
   SDL_GPUTexture *clear_color_texture();
   SDL_GPUTexture *framebuffer_color(uint32_t id);
+  SDL_GPUTexture *framebuffer_depth(uint32_t id);
   void framebuffer_size(uint32_t id, int *width, int *height);
   /** Release every GPU handle this context owns, keeping the CPU-side object
    * table. Used by the destructor and by `lose_context`. */
@@ -490,7 +360,19 @@ class WebGLContext {
   int draw_color_layer(int slot);
   SDL_GPUTexture *ensure_texture_gpu(WebGLTexture *texture, bool as_target);
   SDL_GPUSampler *sampler_for(WebGLTexture *texture);
+  SDL_GPUSampler *sampler_for_compare(WebGLTexture *texture);
   SDL_GPUBuffer *ensure_buffer_gpu(WebGLBuffer *buffer);
+  /** Upload `size` bytes at `offset` into an existing GPU buffer, ending the
+   * open render pass first (a copy pass cannot run inside one). */
+  bool upload_buffer_range(SDL_GPUBuffer *gpu, uint32_t offset, const void *bytes, uint32_t size);
+  /** The persistent GPU buffer for a disabled attribute's `current[]` value. */
+  SDL_GPUBuffer *constant_attrib_buffer(int index);
+  /** Hash the current fixed-function state into a draw key. */
+  void draw_state_hash(uint64_t *first, uint64_t *second) const;
+  /** The prepared pipeline/layout for `key`, building and caching it on miss. */
+  const WebGLDrawSetup *prepare_draw(const WebGLDrawKey &key);
+  /** Drop every prepared draw and pipeline key (state/layout changed shape). */
+  void clear_draw_cache();
   void ensure_default_target();
   void rebuild_default_target();
   bool ensure_fallback();
@@ -502,11 +384,10 @@ class WebGLContext {
   SDL_GPUSampler *sampler_gpu(WebGLSampler *sampler);
   uint32_t buffer_for_target(int target) const;
   void release_program_pipelines(WebGLProgram *program);
-  SDL_GPUGraphicsPipeline *create_pipeline(WebGLProgram *program, int mode, int index_type,
+  SDL_GPUGraphicsPipeline *create_pipeline(WebGLProgram *program, int mode,
                                            int attribute_count, int buffer_count,
                                            const SDL_GPUVertexAttribute *attrs,
-                                           const SDL_GPUVertexBufferDescription *buffers,
-                                           const std::string &key);
+                                           const SDL_GPUVertexBufferDescription *buffers);
 
   uint64_t id_ = 0;
   int width_ = 0;
@@ -518,6 +399,23 @@ class WebGLContext {
   SDL_GPURenderPass *pass_ = nullptr;
   bool pass_targets_default_ = true;
   uint32_t pass_framebuffer_ = 0;
+  /** Bumped every time a render pass is actually opened: bindings recorded in
+   * a previous pass do not survive an intervening upload. */
+  uint64_t pass_serial_ = 0;
+  /** State-shape versions. A mutation that changes the vertex layout, the GPU
+   * buffer handles or the attachment formats bumps one of these, which
+   * invalidates every prepared draw. */
+  uint64_t attribs_version_ = 1;
+  uint64_t gpu_version_ = 1;
+  uint64_t framebuffer_version_ = 1;
+  std::unordered_map<WebGLDrawKey, WebGLDrawSetup, WebGLDrawKeyHash> draw_setups_;
+  SDL_GPUGraphicsPipeline *last_pipeline_ = nullptr;
+  const WebGLDrawSetup *last_setup_ = nullptr;
+  uint64_t last_setup_pass_ = 0;
+  /** Pipelines for internal helper draws (depth blit), keyed by their state. */
+  std::unordered_map<std::string, SDL_GPUGraphicsPipeline *> internal_pipelines_;
+  /** Scratch for the sampler bindings of one draw. */
+  std::vector<SDL_GPUTextureSamplerBinding> sampler_bindings_;
 
   SDL_GPUTexture *color_ = nullptr;
   SDL_GPUTexture *depth_ = nullptr;
@@ -528,6 +426,10 @@ class WebGLContext {
   /** Internal program/buffer for a scissored depth/stencil clear. */
   uint32_t clear_program_ = 0;
   uint32_t clear_buffer_ = 0;
+  /** Internal program/buffer/sampler for a depth blit. */
+  uint32_t blit_program_ = 0;
+  uint32_t blit_buffer_ = 0;
+  SDL_GPUSampler *blit_sampler_ = nullptr;
 
   float clear_color_[4] = {0.0f, 0.0f, 0.0f, 0.0f};
   float clear_depth_ = 1.0f;

package/runtime/ext_gui/webgl_blit.cpp

@@ -19,10 +19,21 @@ namespace xtgui {
 
 bool WebGLContext::blit_framebuffer(const int source[4], const int destination[4], int mask,
                                     int filter) {
-  if ((mask & GL_COLOR_BUFFER_BIT) == 0) return true;
+  const bool color_bit = (mask & GL_COLOR_BUFFER_BIT) != 0;
+  const bool depth_bit = (mask & GL_DEPTH_BUFFER_BIT) != 0;
+  if (!color_bit && !depth_bit) return true;
   end_pass();
   ensure_command();
   if (cmd_ == nullptr) return false;
+  if (depth_bit) {
+    /* SDL_GPU's blit API is colour-only; the depth copy is a sampling pass that
+     * writes `gl_FragDepth`. Stencil bits have no sampleable representation and
+     * are left untouched. */
+    blit_depth(read_framebuffer_, bound_framebuffer_, source, destination);
+    end_pass();
+    ensure_command();
+  }
+  if (!color_bit) return true;
   SDL_GPUTexture *source_texture = framebuffer_color(read_framebuffer_);
   SDL_GPUTexture *destination_texture = framebuffer_color(bound_framebuffer_);
   if (source_texture == nullptr || destination_texture == nullptr ||

package/runtime/ext_gui/webgl_blit_depth.cpp

@@ -0,0 +1,270 @@
+/*
+ * xbintsc GUI engine — `blitFramebuffer` depth copies.
+ *
+ * SDL_GPU's blit copies colour attachments only. A depth attachment can still
+ * be sampled as an ordinary texture, so a full-screen quad samples the source
+ * depth and writes it back with `gl_FragDepth` while colour writes are masked
+ * off. Stencil is not sampleable through SDL_GPU and is left untouched.
+ *
+ * The internal program, quad buffer and sampler are ordinary engine objects and
+ * live for the context's lifetime. The caller's GL state is saved/restored
+ * around the draw.
+ */
+
+#include "webgl.h"
+
+#include <algorithm>
+#include <cstring>
+#include <string>
+
+#include "gui_internal.h"
+
+namespace xtgui {
+namespace {
+
+const char *kBlitVertexShader =
+    "#version 300 es\n"
+    "uniform highp vec4 u_dst;\n"
+    "uniform highp vec4 u_uv;\n"
+    "in highp vec2 a_pos;\n"
+    "out highp vec2 v_uv;\n"
+    "void main() {\n"
+    "  v_uv = mix(u_uv.xy, u_uv.zw, a_pos);\n"
+    "  gl_Position = vec4(mix(u_dst.xy, u_dst.zw, a_pos), 0.0, 1.0);\n"
+    "}\n";
+
+const char *kBlitFragmentShader =
+    "#version 300 es\n"
+    "precision highp float;\n"
+    "uniform highp vec4 u_dst;\n"
+    "uniform highp sampler2D u_depth;\n"
+    "in highp vec2 v_uv;\n"
+    "out highp vec4 fragColor;\n"
+    "void main() {\n"
+    "  fragColor = vec4(1.0);\n"
+    "  gl_FragDepth = texture(u_depth, v_uv).r;\n"
+    "}\n";
+
+}  // namespace
+
+bool WebGLContext::blit_depth(uint32_t source_framebuffer, uint32_t destination_framebuffer,
+                              const int source[4], const int destination[4]) {
+  if (guidev::g_device == nullptr) return false;
+  if (source_framebuffer == destination_framebuffer) return false;
+  /* A renderbuffer depth attachment is never created with SAMPLER usage. */
+  if (source_framebuffer != 0) {
+    WebGLFramebuffer *framebuffer = this->framebuffer(source_framebuffer);
+    if (framebuffer == nullptr || framebuffer->depth_texture == 0) return false;
+  }
+  if (destination_framebuffer != 0 && this->framebuffer(destination_framebuffer) == nullptr) {
+    return false;
+  }
+
+  int source_width = 0;
+  int source_height = 0;
+  int destination_width = 0;
+  int destination_height = 0;
+  framebuffer_size(source_framebuffer, &source_width, &source_height);
+  framebuffer_size(destination_framebuffer, &destination_width, &destination_height);
+  if (source_width <= 0 || source_height <= 0 || destination_width <= 0 ||
+      destination_height <= 0) {
+    return false;
+  }
+  int sx0 = source[0];
+  int sy0 = source[1];
+  int sx1 = source[2];
+  int sy1 = source[3];
+  int dx0 = destination[0];
+  int dy0 = destination[1];
+  int dx1 = destination[2];
+  int dy1 = destination[3];
+  if (sx1 < sx0) std::swap(sx0, sx1);
+  if (sy1 < sy0) std::swap(sy0, sy1);
+  if (dx1 < dx0) std::swap(dx0, dx1);
+  if (dy1 < dy0) std::swap(dy0, dy1);
+  sx0 = std::max(0, std::min(sx0, source_width));
+  sx1 = std::max(0, std::min(sx1, source_width));
+  sy0 = std::max(0, std::min(sy0, source_height));
+  sy1 = std::max(0, std::min(sy1, source_height));
+  dx0 = std::max(0, std::min(dx0, destination_width));
+  dx1 = std::max(0, std::min(dx1, destination_width));
+  dy0 = std::max(0, std::min(dy0, destination_height));
+  dy1 = std::max(0, std::min(dy1, destination_height));
+  if (sx1 <= sx0 || sy1 <= sy0 || dx1 <= dx0 || dy1 <= dy0) return true;
+  SDL_GPUTexture *source_depth = framebuffer_depth(source_framebuffer);
+  SDL_GPUTexture *destination_depth = framebuffer_depth(destination_framebuffer);
+  if (source_depth == nullptr || destination_depth == nullptr ||
+      source_depth == destination_depth) {
+    return false;
+  }
+
+  /* Build the internal program/buffer on first use. */
+  if (blit_program_ == 0) {
+    const uint32_t vs = create_shader(GL_VERTEX_SHADER);
+    shader_source(vs, kBlitVertexShader);
+    const uint32_t fs = create_shader(GL_FRAGMENT_SHADER);
+    shader_source(fs, kBlitFragmentShader);
+    if (compile_shader(vs) && compile_shader(fs)) {
+      const uint32_t program_id = create_program();
+      attach_shader(program_id, vs);
+      attach_shader(program_id, fs);
+      bind_attrib_location(program_id, 0, "a_pos");
+      if (link_program(program_id)) {
+        blit_program_ = program_id;
+      } else {
+        delete_program(program_id);
+      }
+    }
+    if (blit_program_ == 0) {
+      delete_shader(vs);
+      delete_shader(fs);
+      return false;
+    }
+  }
+  if (blit_buffer_ == 0) {
+    blit_buffer_ = create_buffer();
+    bind_buffer(GL_ARRAY_BUFFER, blit_buffer_);
+    const float vertices[8] = {0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f};
+    buffer_data(blit_buffer_, (const uint8_t *)vertices, (uint32_t)sizeof(vertices),
+                GL_STATIC_DRAW);
+  }
+  if (blit_sampler_ == nullptr) {
+    SDL_GPUSamplerCreateInfo sampler_info;
+    memset(&sampler_info, 0, sizeof(sampler_info));
+    sampler_info.min_filter = SDL_GPU_FILTER_NEAREST;
+    sampler_info.mag_filter = SDL_GPU_FILTER_NEAREST;
+    sampler_info.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST;
+    sampler_info.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    sampler_info.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    sampler_info.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;
+    sampler_info.max_lod = 0.0f;
+    blit_sampler_ = SDL_CreateGPUSampler(guidev::g_device, &sampler_info);
+  }
+  WebGLProgram *program = this->program(blit_program_);
+  WebGLBuffer *quad_buffer = buffer(blit_buffer_);
+  SDL_GPUBuffer *quad_gpu = quad_buffer != nullptr ? ensure_buffer_gpu(quad_buffer) : nullptr;
+  if (program == nullptr || program->vs_shader == nullptr || program->fs_shader == nullptr ||
+      quad_gpu == nullptr || blit_sampler_ == nullptr) {
+    return false;
+  }
+
+  /* NDC rectangle and source UVs. Source V is flipped because GL's origin is
+   * bottom-left while SDL_GPU's render targets and uploads are top-down. */
+  double dst[4] = {(double)dx0 / (double)destination_width * 2.0 - 1.0,
+                   (double)dy0 / (double)destination_height * 2.0 - 1.0,
+                   (double)dx1 / (double)destination_width * 2.0 - 1.0,
+                   (double)dy1 / (double)destination_height * 2.0 - 1.0};
+  double uv[4] = {(double)sx0 / (double)source_width,
+                  1.0 - (double)sy0 / (double)source_height,
+                  (double)sx1 / (double)source_width,
+                  1.0 - (double)sy1 / (double)source_height};
+
+  const WebGLDrawState saved_state = state_;
+  const uint32_t saved_program = current_program_;
+  state_.blend = false;
+  state_.cull = false;
+  state_.stencil = false;
+  state_.depth_test = true;
+  state_.depth_write = true;
+  state_.depth_func = GL_ALWAYS;
+  for (bool &channel : state_.color_mask) channel = false;
+  state_.color_target_count = 0;
+  for (int slot = 0; slot < kWebGLMaxDrawBuffers; slot++) {
+    if (draw_color_texture(slot) == nullptr) continue;
+    state_.color_formats[state_.color_target_count++] = draw_color_format(slot);
+  }
+  if (state_.color_target_count == 0) state_.color_target_count = 1;
+  state_.depth_format = target_depth_format();
+  current_program_ = blit_program_;
+
+  std::string key = "blit-depth/";
+  for (int i = 0; i < state_.color_target_count; i++) {
+    key += std::to_string(state_.color_formats[i]) + ",";
+  }
+  key += std::to_string(state_.depth_format);
+  SDL_GPUVertexAttribute attribute;
+  memset(&attribute, 0, sizeof(attribute));
+  attribute.location = 0;
+  attribute.buffer_slot = 0;
+  attribute.format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2;
+  attribute.offset = 0;
+  SDL_GPUVertexBufferDescription buffer_description;
+  memset(&buffer_description, 0, sizeof(buffer_description));
+  buffer_description.slot = 0;
+  buffer_description.pitch = 8;
+  buffer_description.input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
+  SDL_GPUGraphicsPipeline *pipeline = nullptr;
+  auto cached = internal_pipelines_.find(key);
+  if (cached != internal_pipelines_.end()) {
+    pipeline = cached->second;
+  } else {
+    pipeline = create_pipeline(program, GL_TRIANGLE_STRIP, 1, 1, &attribute, &buffer_description);
+    if (pipeline != nullptr) internal_pipelines_[key] = pipeline;
+  }
+  bool ok = pipeline != nullptr;
+  if (ok) {
+    begin_pass(false, false, false);
+    ok = pass_ != nullptr;
+  }
+  if (ok) {
+    SDL_BindGPUGraphicsPipeline(pass_, pipeline);
+    SDL_GPUBufferBinding binding;
+    memset(&binding, 0, sizeof(binding));
+    binding.buffer = quad_gpu;
+    SDL_BindGPUVertexBuffers(pass_, 0, &binding, 1);
+    SDL_Rect scissor;
+    scissor.x = 0;
+    scissor.y = 0;
+    scissor.w = destination_width;
+    scissor.h = destination_height;
+    if (scissor_test_ && scissor_box_[2] > 0 && scissor_box_[3] > 0) {
+      scissor.x = scissor_box_[0];
+      scissor.y = destination_height - (scissor_box_[1] + scissor_box_[3]);
+      scissor.w = scissor_box_[2];
+      scissor.h = scissor_box_[3];
+    }
+    if (scissor.x < 0) {
+      scissor.w += scissor.x;
+      scissor.x = 0;
+    }
+    if (scissor.y < 0) {
+      scissor.h += scissor.y;
+      scissor.y = 0;
+    }
+    if (scissor.x + scissor.w > destination_width) scissor.w = destination_width - scissor.x;
+    if (scissor.y + scissor.h > destination_height) scissor.h = destination_height - scissor.y;
+    if (scissor.w < 0) scissor.w = 0;
+    if (scissor.h < 0) scissor.h = 0;
+    SDL_SetGPUScissor(pass_, &scissor);
+
+    const int dst_location = uniform_location(blit_program_, "u_dst");
+    const int uv_location = uniform_location(blit_program_, "u_uv");
+    if (dst_location >= 0) uniform_floats(blit_program_, dst_location, 4, dst, 1);
+    if (uv_location >= 0) uniform_floats(blit_program_, uv_location, 4, uv, 1);
+    if (program->block_size > 0) {
+      if (program->vs_has_block) {
+        SDL_PushGPUVertexUniformData(cmd_, 0, program->block.data(),
+                                     (Uint32)program->block.size());
+      }
+      if (program->fs_has_block) {
+        SDL_PushGPUFragmentUniformData(cmd_, 0, program->block.data(),
+                                       (Uint32)program->block.size());
+      }
+    }
+    SDL_GPUTextureSamplerBinding sampler_binding;
+    sampler_binding.texture = source_depth;
+    sampler_binding.sampler = blit_sampler_;
+    SDL_BindGPUFragmentSamplers(pass_, 0, &sampler_binding, 1);
+    SDL_DrawGPUPrimitives(pass_, 4, 1, 0, 0);
+  }
+
+  state_ = saved_state;
+  current_program_ = saved_program;
+  /* This pass bound the blit pipeline directly, outside the prepared-draw
+   * cache; a later draw in the same pass must bind its own pipeline again. */
+  last_setup_ = nullptr;
+  last_pipeline_ = nullptr;
+  return ok;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_buffer.cpp

@@ -58,6 +58,27 @@ SDL_GPUSamplerAddressMode address_of(int wrap) {
   }
 }
 
+SDL_GPUCompareOp compare_of(int func) {
+  switch (func) {
+    case GL_NEVER:
+      return SDL_GPU_COMPAREOP_NEVER;
+    case GL_LESS:
+      return SDL_GPU_COMPAREOP_LESS;
+    case GL_EQUAL:
+      return SDL_GPU_COMPAREOP_EQUAL;
+    case GL_LEQUAL:
+      return SDL_GPU_COMPAREOP_LESS_OR_EQUAL;
+    case GL_GREATER:
+      return SDL_GPU_COMPAREOP_GREATER;
+    case GL_NOTEQUAL:
+      return SDL_GPU_COMPAREOP_NOT_EQUAL;
+    case GL_GEQUAL:
+      return SDL_GPU_COMPAREOP_GREATER_OR_EQUAL;
+    default:
+      return SDL_GPU_COMPAREOP_ALWAYS;
+  }
+}
+
 }  // namespace
 
 /* -- textures ------------------------------------------------------------ */
@@ -111,6 +132,9 @@ void WebGLContext::delete_texture(uint32_t id) {
     if (found->second->sampler != nullptr) {
       SDL_ReleaseGPUSampler(guidev::g_device, found->second->sampler);
     }
+    if (found->second->compare_sampler != nullptr) {
+      SDL_ReleaseGPUSampler(guidev::g_device, found->second->compare_sampler);
+    }
   }
   textures_.erase(found);
 }
@@ -159,17 +183,29 @@ bool WebGLContext::tex_parameter(uint32_t id, int pname, int value) {
   else if (pname == GL_TEXTURE_MAG_FILTER) record->mag_filter = value;
   else if (pname == GL_TEXTURE_WRAP_S) record->wrap_s = value;
   else if (pname == GL_TEXTURE_WRAP_T) record->wrap_t = value;
-  else return true;  // other parameters are accepted and ignored
+  else if (pname == GL_TEXTURE_COMPARE_MODE) {
+    record->compare_mode = value == GL_COMPARE_REF_TO_TEXTURE;
+  } else if (pname == GL_TEXTURE_COMPARE_FUNC) {
+    record->compare_func = value;
+  } else return true;  // other parameters are accepted and ignored
   if (record->sampler != nullptr && guidev::g_device != nullptr) {
     SDL_ReleaseGPUSampler(guidev::g_device, record->sampler);
     record->sampler = nullptr;
   }
+  if (record->compare_sampler != nullptr && guidev::g_device != nullptr) {
+    SDL_ReleaseGPUSampler(guidev::g_device, record->compare_sampler);
+    record->compare_sampler = nullptr;
+  }
   return true;
 }
 
 int WebGLContext::tex_parameter_value(uint32_t id, int pname) {
   WebGLTexture *record = texture(id);
   if (record == nullptr) return 0;
+  if (pname == GL_TEXTURE_COMPARE_MODE) {
+    return record->compare_mode ? GL_COMPARE_REF_TO_TEXTURE : GL_NONE;
+  }
+  if (pname == GL_TEXTURE_COMPARE_FUNC) return record->compare_func;
   if (pname == GL_TEXTURE_MIN_FILTER) return record->min_filter;
   if (pname == GL_TEXTURE_MAG_FILTER) return record->mag_filter;
   if (pname == GL_TEXTURE_WRAP_S) return record->wrap_s;
@@ -269,6 +305,25 @@ SDL_GPUSampler *WebGLContext::sampler_for(WebGLTexture *record) {
   return record->sampler;
 }
 
+SDL_GPUSampler *WebGLContext::sampler_for_compare(WebGLTexture *record) {
+  if (record == nullptr || guidev::g_device == nullptr) return nullptr;
+  if (record->compare_sampler != nullptr) return record->compare_sampler;
+  SDL_GPUSamplerCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.min_filter = SDL_GPU_FILTER_LINEAR;
+  info.mag_filter = SDL_GPU_FILTER_LINEAR;
+  info.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST;
+  info.address_mode_u = address_of(record->wrap_s);
+  info.address_mode_v = address_of(record->wrap_t);
+  info.address_mode_w = address_of(record->wrap_t);
+  info.min_lod = 0.0f;
+  info.max_lod = record->has_mipmaps ? 1000.0f : 0.0f;
+  info.enable_compare = true;
+  info.compare_op = compare_of(record->compare_func);
+  record->compare_sampler = SDL_CreateGPUSampler(guidev::g_device, &info);
+  return record->compare_sampler;
+}
+
 int WebGLContext::texture_width(uint32_t id) {
   WebGLTexture *record = texture(id);
   return record != nullptr ? record->width : 0;
@@ -317,12 +372,14 @@ void WebGLContext::bind_framebuffer(int target, uint32_t id) {
   if (target != GL_FRAMEBUFFER && target != GL_DRAW_FRAMEBUFFER) return;
   if (id != bound_framebuffer_) end_pass();
   bound_framebuffer_ = id;
+  framebuffer_version_ += 1;
   if (target == GL_FRAMEBUFFER) read_framebuffer_ = id;
   read_buffer_ = id == 0 ? GL_BACK : GL_COLOR_ATTACHMENT0;
 }
 
 bool WebGLContext::framebuffer_texture(uint32_t framebuffer_id, uint32_t texture_id,
                                        int attachment) {
+  framebuffer_version_ += 1;
   WebGLFramebuffer *record_framebuffer = framebuffer(framebuffer_id);
   WebGLTexture *record = texture(texture_id);
   if (record_framebuffer == nullptr) return false;
@@ -436,6 +493,7 @@ bool WebGLContext::renderbuffer_storage(uint32_t id, int width, int height, bool
 }
 
 bool WebGLContext::framebuffer_renderbuffer(uint32_t framebuffer_id, uint32_t renderbuffer_id) {
+  framebuffer_version_ += 1;
   WebGLFramebuffer *framebuffer_ = framebuffer(framebuffer_id);
   WebGLRenderbuffer *record = renderbuffer(renderbuffer_id);
   if (framebuffer_ == nullptr) return false;