xbintsc 0.5.32 → 0.5.36

package/runtime/ext_gui/webgl_context.cpp

@@ -1,11 +1,11 @@
 /*
- * xbintsc GUI engine — WebGL context lifetime, GPU targets and fixed-function
- * state.
+ * xbintsc GUI engine — WebGL context lifetime and GPU targets.
  *
  * Every context records into one SDL_GPU command buffer. A render pass stays
  * open across draws and is ended whenever a copy pass (buffer/texture upload)
  * or a different attachment has to be recorded; the next draw starts a new
  * pass with `LOAD`, so the framebuffer persists like a WebGL drawing buffer.
+ * Fixed-function state lives in `webgl_state.cpp`.
  */
 
 #include "webgl.h"
@@ -46,38 +46,130 @@ WebGLContext::WebGLContext(uint64_t id, int width, int height, bool webgl2)
 
 WebGLContext::~WebGLContext() {
   submit();
-  if (guidev::g_device != nullptr) {
-    SDL_WaitForGPUIdle(guidev::g_device);
-    for (auto &entry : programs_) release_program_pipelines(entry.second.get());
-    for (auto &entry : textures_) {
-      if (entry.second->gpu != nullptr) SDL_ReleaseGPUTexture(guidev::g_device, entry.second->gpu);
-      if (entry.second->sampler != nullptr) {
-        SDL_ReleaseGPUSampler(guidev::g_device, entry.second->sampler);
-      }
-    }
-    for (auto &entry : buffers_) {
-      if (entry.second->gpu != nullptr) SDL_ReleaseGPUBuffer(guidev::g_device, entry.second->gpu);
-    }
-    for (auto &entry : samplers_) {
-      if (entry.second->gpu != nullptr) {
-        SDL_ReleaseGPUSampler(guidev::g_device, entry.second->gpu);
-      }
+  if (guidev::g_device != nullptr) release_gpu_resources();
+  g_contexts.erase(id_);
+}
+
+void WebGLContext::release_gpu_resources() {
+  if (guidev::g_device == nullptr) return;
+  SDL_WaitForGPUIdle(guidev::g_device);
+  for (auto &entry : programs_) release_program_pipelines(entry.second.get());
+  for (auto &entry : textures_) {
+    if (entry.second->gpu != nullptr) SDL_ReleaseGPUTexture(guidev::g_device, entry.second->gpu);
+    if (entry.second->sampler != nullptr) {
+      SDL_ReleaseGPUSampler(guidev::g_device, entry.second->sampler);
     }
-    for (auto &entry : framebuffers_) {
-      if (entry.second->depth != nullptr) SDL_ReleaseGPUTexture(guidev::g_device, entry.second->depth);
+    entry.second->gpu = nullptr;
+    entry.second->sampler = nullptr;
+  }
+  for (auto &entry : buffers_) {
+    if (entry.second->gpu != nullptr) SDL_ReleaseGPUBuffer(guidev::g_device, entry.second->gpu);
+    entry.second->gpu = nullptr;
+    entry.second->capacity = 0;
+  }
+  for (auto &entry : samplers_) {
+    if (entry.second->gpu != nullptr) {
+      SDL_ReleaseGPUSampler(guidev::g_device, entry.second->gpu);
+      entry.second->gpu = nullptr;
     }
-    for (auto &entry : renderbuffers_) {
-      if (entry.second->depth != nullptr) SDL_ReleaseGPUTexture(guidev::g_device, entry.second->depth);
+  }
+  for (auto &entry : framebuffers_) {
+    if (entry.second->depth != nullptr) {
+      SDL_ReleaseGPUTexture(guidev::g_device, entry.second->depth);
+      entry.second->depth = nullptr;
     }
-    for (SDL_GPUBuffer *buffer : temp_buffers_) {
-      SDL_ReleaseGPUBuffer(guidev::g_device, buffer);
+  }
+  for (auto &entry : renderbuffers_) {
+    if (entry.second->depth != nullptr) {
+      SDL_ReleaseGPUTexture(guidev::g_device, entry.second->depth);
+      entry.second->depth = nullptr;
     }
-    if (fallback_texture_ != nullptr) SDL_ReleaseGPUTexture(guidev::g_device, fallback_texture_);
-    if (fallback_sampler_ != nullptr) SDL_ReleaseGPUSampler(guidev::g_device, fallback_sampler_);
-    if (color_ != nullptr) SDL_ReleaseGPUTexture(guidev::g_device, color_);
-    if (depth_ != nullptr) SDL_ReleaseGPUTexture(guidev::g_device, depth_);
   }
-  g_contexts.erase(id_);
+  for (SDL_GPUBuffer *buffer : temp_buffers_) SDL_ReleaseGPUBuffer(guidev::g_device, buffer);
+  temp_buffers_.clear();
+  if (fallback_texture_ != nullptr) {
+    SDL_ReleaseGPUTexture(guidev::g_device, fallback_texture_);
+    fallback_texture_ = nullptr;
+  }
+  if (fallback_sampler_ != nullptr) {
+    SDL_ReleaseGPUSampler(guidev::g_device, fallback_sampler_);
+    fallback_sampler_ = nullptr;
+  }
+  if (color_ != nullptr) {
+    SDL_ReleaseGPUTexture(guidev::g_device, color_);
+    color_ = nullptr;
+  }
+  if (depth_ != nullptr) {
+    SDL_ReleaseGPUTexture(guidev::g_device, depth_);
+    depth_ = nullptr;
+  }
+  if (clear_texture_ != nullptr) {
+    SDL_ReleaseGPUTexture(guidev::g_device, clear_texture_);
+    clear_texture_ = nullptr;
+  }
+}
+
+void WebGLContext::lose_context() {
+  if (lost_) return;
+  submit();
+  if (guidev::g_device != nullptr) release_gpu_resources();
+  /* The WebGL spec invalidates every object when the context is lost: a page
+   * that gets `webglcontextlost` must recreate buffers, textures and programs
+   * after the restore. */
+  shaders_.clear();
+  programs_.clear();
+  buffers_.clear();
+  textures_.clear();
+  framebuffers_.clear();
+  renderbuffers_.clear();
+  vertex_arrays_.clear();
+  samplers_.clear();
+  queries_.clear();
+  syncs_.clear();
+  default_vertex_array_ = WebGLVertexArray();
+  for (WebGLAttribState &attrib : attribs_) attrib = WebGLAttribState();
+  current_program_ = 0;
+  bound_array_ = 0;
+  bound_element_ = 0;
+  bound_framebuffer_ = 0;
+  read_framebuffer_ = 0;
+  bound_renderbuffer_ = 0;
+  bound_vertex_array_ = 0;
+  copy_read_buffer_ = 0;
+  copy_write_buffer_ = 0;
+  active_unit_ = 0;
+  for (uint32_t &texture : bound_textures_) texture = 0;
+  for (uint32_t &texture : bound_cube_textures_) texture = 0;
+  for (uint32_t &texture : bound_array_textures_) texture = 0;
+  for (uint32_t &texture : bound_3d_textures_) texture = 0;
+  for (int &target : active_texture_target_) target = GL_TEXTURE_2D;
+  for (uint32_t &sampler : bound_samplers_) sampler = 0;
+  state_ = WebGLDrawState();
+  scissor_test_ = false;
+  error_ = 0;
+  lost_ = true;
+  clear_program_ = 0;
+  clear_buffer_ = 0;
+}
+
+void WebGLContext::restore_context() {
+  if (!lost_) return;
+  if (guidev::g_device == nullptr) return;
+  lost_ = false;
+  error_ = 0;
+  ensure_default_target();
+}
+
+void WebGLContext::drawing_buffer_storage(int width, int height) {
+  if (width <= 0 || height <= 0) {
+    set_error(GL_INVALID_VALUE);
+    return;
+  }
+  fixed_storage_ = true;
+  if (width == width_ && height == height_) return;
+  width_ = width;
+  height_ = height;
+  rebuild_default_target();
 }
 
 /* -- targets ------------------------------------------------------------- */
@@ -105,7 +197,7 @@ void WebGLContext::ensure_default_target() {
   info.num_levels = 1;
   info.sample_count = SDL_GPU_SAMPLECOUNT_1;
   if (color_ == nullptr) color_ = SDL_CreateGPUTexture(guidev::g_device, &info);
-  info.format = SDL_GPU_TEXTUREFORMAT_D32_FLOAT;
+  info.format = SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
   info.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET;
   if (depth_ == nullptr) depth_ = SDL_CreateGPUTexture(guidev::g_device, &info);
 }
@@ -129,11 +221,15 @@ void WebGLContext::rebuild_default_target() {
 }
 
 SDL_GPUTexture *WebGLContext::color_texture() {
+  if (lost_) return nullptr;
   ensure_default_target();
   return color_;
 }
 
 void WebGLContext::resize(int width, int height) {
+  /* After `drawingBufferStorage` the drawing buffer has an explicit size and a
+   * canvas resize no longer changes it (WebGL 2). */
+  if (fixed_storage_) return;
   if (width < 0) width = 0;
   if (height < 0) height = 0;
   width_ = width > 0 ? width : 1;
@@ -165,12 +261,34 @@ SDL_GPUTexture *WebGLContext::target_color() {
     return color_;
   }
   WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
-  if (framebuffer == nullptr || framebuffer->color_texture == 0) return nullptr;
-  WebGLTexture *texture = this->texture(framebuffer->color_texture);
+  if (framebuffer == nullptr || framebuffer->color_textures[0] == 0) return nullptr;
+  WebGLTexture *texture = this->texture(framebuffer->color_textures[0]);
   if (texture == nullptr) return nullptr;
   return ensure_texture_gpu(texture, true);
 }
 
+SDL_GPUTexture *WebGLContext::framebuffer_color(uint32_t id) {
+  if (id == 0) {
+    ensure_default_target();
+    return color_;
+  }
+  WebGLFramebuffer *framebuffer_ = framebuffer(id);
+  if (framebuffer_ == nullptr || framebuffer_->color_textures[0] == 0) return nullptr;
+  WebGLTexture *texture_ = texture(framebuffer_->color_textures[0]);
+  return texture_ != nullptr ? ensure_texture_gpu(texture_, true) : nullptr;
+}
+
+void WebGLContext::framebuffer_size(uint32_t id, int *width, int *height) {
+  if (id == 0) {
+    *width = width_;
+    *height = height_;
+    return;
+  }
+  WebGLFramebuffer *framebuffer_ = framebuffer(id);
+  *width = framebuffer_ != nullptr ? framebuffer_->width : 0;
+  *height = framebuffer_ != nullptr ? framebuffer_->height : 0;
+}
+
 SDL_GPUTexture *WebGLContext::target_depth() {
   if (bound_framebuffer_ == 0) {
     ensure_default_target();
@@ -178,12 +296,18 @@ SDL_GPUTexture *WebGLContext::target_depth() {
   }
   WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
   if (framebuffer == nullptr) return nullptr;
+  if (framebuffer->depth_texture != 0) {
+    WebGLTexture *texture = this->texture(framebuffer->depth_texture);
+    if (texture == nullptr) return nullptr;
+    texture->as_depth_target = true;
+    return ensure_texture_gpu(texture, true);
+  }
   if (framebuffer->depth == nullptr && framebuffer->depth_renderbuffer == 0 &&
       framebuffer->width > 0 && framebuffer->height > 0 && guidev::g_device != nullptr) {
     SDL_GPUTextureCreateInfo info;
     memset(&info, 0, sizeof(info));
     info.type = SDL_GPU_TEXTURETYPE_2D;
-    info.format = SDL_GPU_TEXTUREFORMAT_D32_FLOAT;
+    info.format = SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
     info.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET;
     info.width = (Uint32)framebuffer->width;
     info.height = (Uint32)framebuffer->height;
@@ -195,6 +319,27 @@ SDL_GPUTexture *WebGLContext::target_depth() {
   return framebuffer->depth;
 }
 
+int WebGLContext::target_color_format() {
+  if (bound_framebuffer_ == 0) return SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
+  if (framebuffer == nullptr || framebuffer->color_textures[0] == 0) {
+    return SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  }
+  WebGLTexture *texture = this->texture(framebuffer->color_textures[0]);
+  return texture != nullptr ? (int)texture->format : SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+}
+
+int WebGLContext::target_depth_format() {
+  if (bound_framebuffer_ == 0) return SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
+  WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
+  if (framebuffer == nullptr) return SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
+  if (framebuffer->depth_texture != 0) {
+    WebGLTexture *texture = this->texture(framebuffer->depth_texture);
+    if (texture != nullptr) return (int)texture->format;
+  }
+  return SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
+}
+
 void WebGLContext::end_pass() {
   if (pass_ != nullptr && cmd_ != nullptr) {
     SDL_EndGPURenderPass(pass_);
@@ -202,30 +347,37 @@ void WebGLContext::end_pass() {
   }
 }
 
-void WebGLContext::begin_pass(bool clear_color, bool clear_depth) {
+void WebGLContext::begin_pass(bool clear_color, bool clear_depth, bool clear_stencil) {
   if (guidev::g_device == nullptr) return;
   if (pass_ != nullptr && pass_targets_default_ == (bound_framebuffer_ == 0) &&
-      pass_framebuffer_ == bound_framebuffer_ && !clear_color && !clear_depth) {
+      pass_framebuffer_ == bound_framebuffer_ && !clear_color && !clear_depth &&
+      !clear_stencil) {
     return;
   }
   end_pass();
   ensure_command();
   if (cmd_ == nullptr) return;
-  SDL_GPUTexture *color = target_color();
   SDL_GPUTexture *depth = target_depth();
-  if (color == nullptr) {
+  SDL_GPUColorTargetInfo color_infos[kWebGLMaxDrawBuffers];
+  int color_count = 0;
+  for (int slot = 0; slot < kWebGLMaxDrawBuffers; slot++) {
+    SDL_GPUTexture *color = draw_color_texture(slot);
+    if (color == nullptr) continue;
+    SDL_GPUColorTargetInfo &color_info = color_infos[color_count++];
+    memset(&color_info, 0, sizeof(color_info));
+    color_info.texture = color;
+    color_info.layer_or_depth_plane = (Uint32)draw_color_layer(slot);
+    color_info.clear_color.r = clear_color_[0];
+    color_info.clear_color.g = clear_color_[1];
+    color_info.clear_color.b = clear_color_[2];
+    color_info.clear_color.a = clear_color_[3];
+    color_info.load_op = clear_color ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD;
+    color_info.store_op = SDL_GPU_STOREOP_STORE;
+  }
+  if (color_count == 0) {
     set_error(GL_INVALID_FRAMEBUFFER_OPERATION);
     return;
   }
-  SDL_GPUColorTargetInfo color_info;
-  memset(&color_info, 0, sizeof(color_info));
-  color_info.texture = color;
-  color_info.clear_color.r = clear_color_[0];
-  color_info.clear_color.g = clear_color_[1];
-  color_info.clear_color.b = clear_color_[2];
-  color_info.clear_color.a = clear_color_[3];
-  color_info.load_op = clear_color ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD;
-  color_info.store_op = SDL_GPU_STOREOP_STORE;
 
   SDL_GPUDepthStencilTargetInfo depth_info;
   memset(&depth_info, 0, sizeof(depth_info));
@@ -234,111 +386,17 @@ void WebGLContext::begin_pass(bool clear_color, bool clear_depth) {
   depth_info.load_op = (clear_depth && depth != nullptr) ? SDL_GPU_LOADOP_CLEAR
                                                          : SDL_GPU_LOADOP_LOAD;
   depth_info.store_op = SDL_GPU_STOREOP_STORE;
-  depth_info.stencil_load_op = SDL_GPU_LOADOP_DONT_CARE;
-  depth_info.stencil_store_op = SDL_GPU_STOREOP_DONT_CARE;
+  depth_info.clear_stencil = (Uint8)(clear_stencil_ & 0xFF);
+  depth_info.stencil_load_op = (clear_stencil && depth != nullptr) ? SDL_GPU_LOADOP_CLEAR
+                                                                  : SDL_GPU_LOADOP_LOAD;
+  depth_info.stencil_store_op = SDL_GPU_STOREOP_STORE;
 
-  pass_ = SDL_BeginGPURenderPass(cmd_, &color_info, 1, depth != nullptr ? &depth_info : nullptr);
+  pass_ = SDL_BeginGPURenderPass(cmd_, color_infos, (Uint32)color_count,
+                                 depth != nullptr ? &depth_info : nullptr);
   pass_targets_default_ = bound_framebuffer_ == 0;
   pass_framebuffer_ = bound_framebuffer_;
 }
 
-/* -- state --------------------------------------------------------------- */
-
-void WebGLContext::enable(int cap) {
-  if (cap == GL_BLEND) state_.blend = true;
-  if (cap == GL_DEPTH_TEST) state_.depth_test = true;
-  if (cap == GL_CULL_FACE) state_.cull = true;
-  if (cap == GL_SCISSOR_TEST) scissor_test_ = true;
-  if (cap == GL_STENCIL_TEST) stencil_test_ = true;
-}
-
-void WebGLContext::disable(int cap) {
-  if (cap == GL_BLEND) state_.blend = false;
-  if (cap == GL_DEPTH_TEST) state_.depth_test = false;
-  if (cap == GL_CULL_FACE) state_.cull = false;
-  if (cap == GL_SCISSOR_TEST) scissor_test_ = false;
-  if (cap == GL_STENCIL_TEST) stencil_test_ = false;
-}
-
-bool WebGLContext::is_enabled(int cap) const {
-  if (cap == GL_BLEND) return state_.blend;
-  if (cap == GL_DEPTH_TEST) return state_.depth_test;
-  if (cap == GL_CULL_FACE) return state_.cull;
-  if (cap == GL_SCISSOR_TEST) return scissor_test_;
-  if (cap == GL_STENCIL_TEST) return stencil_test_;
-  return false;
-}
-
-void WebGLContext::clear_color(float r, float g, float b, float a) {
-  clear_color_[0] = r;
-  clear_color_[1] = g;
-  clear_color_[2] = b;
-  clear_color_[3] = a;
-}
-
-void WebGLContext::color_mask(bool r, bool g, bool b, bool a) {
-  state_.color_mask[0] = r;
-  state_.color_mask[1] = g;
-  state_.color_mask[2] = b;
-  state_.color_mask[3] = a;
-}
-
-void WebGLContext::blend_func(int src, int dst) {
-  state_.blend_src_rgb = src;
-  state_.blend_dst_rgb = dst;
-  state_.blend_src_alpha = src;
-  state_.blend_dst_alpha = dst;
-}
-
-void WebGLContext::blend_func_separate(int src_rgb, int dst_rgb, int src_alpha, int dst_alpha) {
-  state_.blend_src_rgb = src_rgb;
-  state_.blend_dst_rgb = dst_rgb;
-  state_.blend_src_alpha = src_alpha;
-  state_.blend_dst_alpha = dst_alpha;
-}
-
-void WebGLContext::blend_equation(int mode) {
-  state_.blend_eq_rgb = mode;
-  state_.blend_eq_alpha = mode;
-}
-
-void WebGLContext::blend_equation_separate(int rgb, int alpha) {
-  state_.blend_eq_rgb = rgb;
-  state_.blend_eq_alpha = alpha;
-}
-
-void WebGLContext::cull_face(int mode) { state_.cull_face = mode; }
-
-void WebGLContext::front_face(int mode) { state_.front_face = mode; }
-
-void WebGLContext::viewport(int x, int y, int w, int h) {
-  viewport_[0] = x;
-  viewport_[1] = y;
-  viewport_[2] = w;
-  viewport_[3] = h;
-}
-
-void WebGLContext::scissor(int x, int y, int w, int h) {
-  scissor_box_[0] = x;
-  scissor_box_[1] = y;
-  scissor_box_[2] = w;
-  scissor_box_[3] = h;
-}
-
-void WebGLContext::clear(int mask) {
-  if (guidev::g_device == nullptr) return;
-  const bool color_bit = (mask & GL_COLOR_BUFFER_BIT) != 0;
-  const bool depth_bit = (mask & GL_DEPTH_BUFFER_BIT) != 0;
-  /* The scissor rectangle is not honoured by a pass-begin clear; WebGL pages
-   * that clear a sub-rectangle are rare and documented as a limitation. */
-  begin_pass(color_bit, depth_bit);
-}
-
-void WebGLContext::finish() {
-  submit();
-  if (guidev::g_device != nullptr) SDL_WaitForGPUIdle(guidev::g_device);
-}
-
 /* -- queries ------------------------------------------------------------- */
 
 double WebGLContext::parameter(int pname) {
@@ -352,7 +410,9 @@ double WebGLContext::parameter(int pname) {
     case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
       return kWebGLMaxTextureUnits * 2;
     case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
-      return 0;
+      /* The vertex stage binds its own sampler set (`SDL_BindGPUVertexSamplers`)
+       * and the translator emits vertex samplers in descriptor set 0. */
+      return kWebGLMaxTextureUnits;
     case GL_MAX_VERTEX_UNIFORM_VECTORS:
     case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
     case GL_MAX_VARYING_VECTORS:
@@ -362,7 +422,7 @@ double WebGLContext::parameter(int pname) {
     case GL_MAX_VIEWPORT_DIMS:
       return 8192;
     case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
-      return 0;
+      return 8192;
     case GL_SAMPLES:
     case GL_SAMPLE_BUFFERS:
       return 0;
@@ -375,7 +435,7 @@ double WebGLContext::parameter(int pname) {
     case GL_DEPTH_BITS:
       return 8;
     case GL_STENCIL_BITS:
-      return 0;
+      return 8;
     case GL_UNPACK_ALIGNMENT:
     case GL_PACK_ALIGNMENT:
       return 4;
@@ -394,13 +454,23 @@ double WebGLContext::parameter(int pname) {
       return 256;
     case GL_MAX_DRAW_BUFFERS:
     case GL_MAX_COLOR_ATTACHMENTS:
-      return 1;
+      return kWebGLMaxDrawBuffers;
+    case GL_READ_BUFFER:
+      return read_buffer_;
+    case GL_DRAW_BUFFER0:
+      return draw_buffer_value(0);
+    case GL_DRAW_BUFFER1:
+      return draw_buffer_value(1);
+    case GL_DRAW_BUFFER2:
+      return draw_buffer_value(2);
+    case GL_DRAW_BUFFER3:
+      return draw_buffer_value(3);
     case GL_MAX_SAMPLES:
       return 0;
     case GL_MAX_UNIFORM_BUFFER_BINDINGS:
     case GL_MAX_VERTEX_UNIFORM_BLOCKS:
     case GL_MAX_FRAGMENT_UNIFORM_BLOCKS:
-      return 0;
+      return 16;
     case GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
       return 256;
     case GL_MAX_ELEMENT_INDEX:
@@ -417,11 +487,7 @@ double WebGLContext::parameter(int pname) {
     case GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS:
     case GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS:
       return 1024;
-    case GL_MAX_UNIFORM_BLOCK_SIZE:
-      return 16384;
-    case GL_READ_BUFFER:
-    case GL_DRAW_BUFFER0:
-      return GL_BACK;
+
     default:
       return 0;
   }
@@ -452,9 +518,28 @@ uint32_t WebGLContext::bound_buffer(int target) const { return buffer_for_target
 
 uint32_t WebGLContext::bound_texture(int unit) const {
   if (unit < 0 || unit >= kWebGLMaxTextureUnits) return 0;
+  const int target = active_texture_target_[unit];
+  if (target == GL_TEXTURE_CUBE_MAP) return bound_cube_textures_[unit];
+  if (target == GL_TEXTURE_2D_ARRAY) return bound_array_textures_[unit];
+  if (target == GL_TEXTURE_3D) return bound_3d_textures_[unit];
   return bound_textures_[unit];
 }
 
+uint32_t WebGLContext::bound_cube_texture(int unit) const {
+  if (unit < 0 || unit >= kWebGLMaxTextureUnits) return 0;
+  return bound_cube_textures_[unit];
+}
+
+uint32_t WebGLContext::bound_array_texture(int unit) const {
+  if (unit < 0 || unit >= kWebGLMaxTextureUnits) return 0;
+  return bound_array_textures_[unit];
+}
+
+uint32_t WebGLContext::bound_3d_texture(int unit) const {
+  if (unit < 0 || unit >= kWebGLMaxTextureUnits) return 0;
+  return bound_3d_textures_[unit];
+}
+
 void WebGLContext::viewport_box(int out[4]) const {
   for (int i = 0; i < 4; i++) out[i] = viewport_[i];
 }

package/runtime/ext_gui/webgl_draw.cpp

@@ -144,6 +144,11 @@ std::string pipeline_key(int mode, int index_size,
                          const std::vector<SDL_GPUVertexBufferDescription> &buffers,
                          const WebGLDrawState &state) {
   std::string key = std::to_string(mode) + "/" + std::to_string(index_size);
+  key += "/f" + std::to_string(state.color_target_count) + ":";
+  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);
   for (const SDL_GPUVertexAttribute &attr : attrs) {
     key += "/" + std::to_string(attr.location) + ":" + std::to_string(attr.buffer_slot) + ":" +
            std::to_string((int)attr.format) + ":" + std::to_string(attr.offset);
@@ -152,7 +157,7 @@ std::string pipeline_key(int mode, int index_size,
     key += "|" + std::to_string(buffer.slot) + ":" + std::to_string(buffer.pitch) + ":" +
            std::to_string((int)buffer.input_rate);
   }
-  char state_key[160];
+  char state_key[256];
   snprintf(state_key, sizeof(state_key), "|%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
            (int)state.blend, state.blend_src_rgb, state.blend_dst_rgb, state.blend_src_alpha,
            state.blend_dst_alpha, state.blend_eq_rgb, state.blend_eq_alpha, (int)state.depth_test,
@@ -162,6 +167,16 @@ std::string pipeline_key(int mode, int index_size,
   key += std::to_string((int)state.color_mask[1]);
   key += std::to_string((int)state.color_mask[2]);
   key += std::to_string((int)state.color_mask[3]);
+  char stencil_key[224];
+  snprintf(stencil_key, sizeof(stencil_key), "|s%d,%d,%d,%d,%d,%u,%d,%d,%d,%d,%u,%u,%u",
+           (int)state.stencil, state.stencil_front.func, state.stencil_front.fail,
+           state.stencil_front.zfail, state.stencil_front.zpass,
+           (unsigned)state.stencil_front.write_mask, state.stencil_back.func,
+           state.stencil_back.fail, state.stencil_back.zfail, state.stencil_back.zpass,
+           (unsigned)state.stencil_back.write_mask,
+           (unsigned)state.stencil_front.value_mask,
+           (unsigned)state.stencil_front.write_mask);
+  key += stencil_key;
   return key;
 }
 
@@ -308,6 +323,15 @@ void WebGLContext::draw(int mode, int first, int count, int index_type, int offs
       bound_framebuffer_ != 0 ? framebuffer(bound_framebuffer_) : nullptr;
   const int target_width = framebuffer_ != nullptr ? framebuffer_->width : width_;
   const int target_height = framebuffer_ != nullptr ? framebuffer_->height : height_;
+  /* A pipeline bakes in the attachment formats; float colour targets, MRT
+   * layouts and depth textures therefore need their own pipeline variants. */
+  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();
 
   std::vector<SDL_GPUVertexAttribute> attributes;
   std::vector<SDL_GPUVertexBufferDescription> buffers;
@@ -381,7 +405,7 @@ void WebGLContext::draw(int mode, int first, int count, int index_type, int offs
     bindings.push_back(binding);
   }
 
-  begin_pass(false, false);
+  begin_pass(false, false, false);
   if (pass_ == nullptr) return;
 
   SDL_GPUViewport viewport;
@@ -431,6 +455,17 @@ void WebGLContext::draw(int mode, int first, int count, int index_type, int offs
   if (pipeline == nullptr) return;
 
   SDL_BindGPUGraphicsPipeline(pass_, pipeline);
+  if (state_.stencil) {
+    SDL_SetGPUStencilReference(pass_, (Uint8)(stencil_reference() & 0xFF));
+  }
+  if (state_.blend) {
+    SDL_FColor constants;
+    constants.r = blend_color_[0];
+    constants.g = blend_color_[1];
+    constants.b = blend_color_[2];
+    constants.a = blend_color_[3];
+    SDL_SetGPUBlendConstants(pass_, constants);
+  }
   if (!bindings.empty()) {
     SDL_BindGPUVertexBuffers(pass_, 0, bindings.data(), (Uint32)bindings.size());
   }
@@ -442,6 +477,28 @@ void WebGLContext::draw(int mode, int first, int count, int index_type, int offs
                            index_size == 4 ? SDL_GPU_INDEXELEMENTSIZE_32BIT
                                            : SDL_GPU_INDEXELEMENTSIZE_16BIT);
   }
+  /* User uniform blocks live in the same std140 block; refresh their members
+   * from the CPU-side buffer bound to each block's binding point. */
+  for (const WebGLUniformBlock &block : program_->blocks) {
+    if (block.binding < 0 || block.binding >= 16) continue;
+    const WebGLUniformBinding &binding = uniform_bindings_[block.binding];
+    if (binding.buffer == 0) continue;
+    WebGLBuffer *uniform_buffer = buffer(binding.buffer);
+    if (uniform_buffer == nullptr) continue;
+    size_t offset = binding.offset;
+    size_t length = (size_t)block.data_size;
+    if (binding.size > 0 && length > binding.size) length = binding.size;
+    if (offset > uniform_buffer->data.size()) continue;
+    if (length > uniform_buffer->data.size() - offset) {
+      length = uniform_buffer->data.size() - offset;
+    }
+    if (block.base_offset >= 0 &&
+        block.base_offset + (int)length <= program_->block_size) {
+      memcpy(program_->block.data() + block.base_offset,
+             uniform_buffer->data.data() + offset, length);
+    }
+  }
+
   if (program_->vs_has_block && program_->block_size > 0) {
     SDL_PushGPUVertexUniformData(cmd_, 0, program_->block.data(), (Uint32)program_->block.size());
   }
@@ -457,7 +514,15 @@ void WebGLContext::draw(int mode, int first, int count, int index_type, int offs
       const WebGLUniform &uniform = program_->uniforms[(size_t)uniform_index];
       const int unit =
           uniform.unit >= 0 && uniform.unit < kWebGLMaxTextureUnits ? uniform.unit : 0;
-      WebGLTexture *sampled = texture(bound_textures_[unit]);
+      uint32_t texture_id = bound_textures_[unit];
+      if (uniform.layout.gl_type == GL_SAMPLER_CUBE) {
+        texture_id = bound_cube_textures_[unit];
+      } else if (uniform.layout.gl_type == GL_SAMPLER_3D) {
+        texture_id = bound_3d_textures_[unit];
+      } else if (uniform.layout.gl_type == GL_SAMPLER_2D_ARRAY) {
+        texture_id = bound_array_textures_[unit];
+      }
+      WebGLTexture *sampled = texture(texture_id);
       SDL_GPUTexture *gpu = sampled != nullptr ? ensure_texture_gpu(sampled, sampled->as_target)
                                                : nullptr;
       WebGLSampler *sampler_object = this->sampler(bound_samplers_[unit]);