xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/webgl_buffer_objects.cpp

@@ -0,0 +1,270 @@
+/*
+ * xbintsc GUI engine — WebGL buffer objects and vertex-attribute state.
+ *
+ * Uploads are recorded immediately: a copy pass cannot run inside a render
+ * pass, so a buffer update ends the open pass first. The next draw starts a
+ * new pass with `LOAD`, so the framebuffer keeps its contents.
+ */
+
+#include "webgl.h"
+
+#include <algorithm>
+#include <cstring>
+
+#include "gui_internal.h"
+
+namespace xtgui {
+namespace {
+
+bool upload_transfer(SDL_GPUDevice *device, SDL_GPUCommandBuffer *cmd, SDL_GPUBuffer *buffer,
+                     const void *bytes, uint32_t size) {
+  if (size == 0) return true;
+  SDL_GPUTransferBufferCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+  info.size = size;
+  SDL_GPUTransferBuffer *transfer = SDL_CreateGPUTransferBuffer(device, &info);
+  if (transfer == nullptr) return false;
+  void *mapped = SDL_MapGPUTransferBuffer(device, transfer, false);
+  if (mapped == nullptr) {
+    SDL_ReleaseGPUTransferBuffer(device, transfer);
+    return false;
+  }
+  memcpy(mapped, bytes, size);
+  SDL_UnmapGPUTransferBuffer(device, transfer);
+  SDL_GPUCopyPass *copy = SDL_BeginGPUCopyPass(cmd);
+  SDL_GPUTransferBufferLocation source;
+  memset(&source, 0, sizeof(source));
+  source.transfer_buffer = transfer;
+  SDL_GPUBufferRegion region;
+  memset(&region, 0, sizeof(region));
+  region.buffer = buffer;
+  region.size = size;
+  SDL_UploadToGPUBuffer(copy, &source, &region, false);
+  SDL_EndGPUCopyPass(copy);
+  SDL_ReleaseGPUTransferBuffer(device, transfer);
+  return true;
+}
+
+}  // namespace
+
+/* -- buffers ------------------------------------------------------------- */
+
+uint32_t WebGLContext::create_buffer() {
+  auto record = std::make_unique<WebGLBuffer>();
+  record->id = next_object_id_++;
+  const uint32_t id = record->id;
+  buffers_[id] = std::move(record);
+  return id;
+}
+
+void WebGLContext::delete_buffer(uint32_t id) {
+  auto found = buffers_.find(id);
+  if (found == buffers_.end()) return;
+  if (bound_array_ == id) bound_array_ = 0;
+  if (bound_element_ == id) bound_element_ = 0;
+  for (WebGLAttribState &attrib : attribs_) {
+    if (attrib.buffer == id) attrib.buffer = 0;
+  }
+  if (found->second->gpu != nullptr && guidev::g_device != nullptr) {
+    submit(); SDL_WaitForGPUIdle(guidev::g_device);
+    SDL_ReleaseGPUBuffer(guidev::g_device, found->second->gpu);
+  }
+  buffers_.erase(found);
+}
+
+void WebGLContext::bind_buffer(int target, uint32_t id) {
+  if (id != 0 && buffers_.find(id) == buffers_.end()) return;
+  if (target == GL_ARRAY_BUFFER) bound_array_ = id;
+  if (target == GL_ELEMENT_ARRAY_BUFFER) bound_element_ = id;
+  if (target == GL_COPY_READ_BUFFER) copy_read_buffer_ = id;
+  if (target == GL_COPY_WRITE_BUFFER) copy_write_buffer_ = id;
+  if (target == GL_UNIFORM_BUFFER) bound_uniform_ = id;
+  if (target == GL_TRANSFORM_FEEDBACK_BUFFER) bound_transform_feedback_ = id;
+}
+
+uint32_t WebGLContext::buffer_for_target(int target) const {
+  if (target == GL_ELEMENT_ARRAY_BUFFER) return bound_element_;
+  if (target == GL_ARRAY_BUFFER) return bound_array_;
+  if (target == GL_COPY_READ_BUFFER) return copy_read_buffer_;
+  if (target == GL_COPY_WRITE_BUFFER) return copy_write_buffer_;
+  if (target == GL_UNIFORM_BUFFER) return bound_uniform_;
+  if (target == GL_TRANSFORM_FEEDBACK_BUFFER) return bound_transform_feedback_;
+  return 0;
+}
+
+bool WebGLContext::copy_buffer_sub_data(int read_target, int write_target, uint32_t read_offset,
+                                        uint32_t write_offset, uint32_t size) {
+  WebGLBuffer *read_buffer = buffer(buffer_for_target(read_target));
+  WebGLBuffer *write_buffer = buffer(buffer_for_target(write_target));
+  if (read_buffer == nullptr || write_buffer == nullptr ||
+      read_offset + size > read_buffer->data.size() ||
+      write_offset + size > write_buffer->data.size()) {
+    set_error(GL_INVALID_VALUE);
+    return false;
+  }
+  if (size > 0) {
+    memmove(write_buffer->data.data() + write_offset,
+            read_buffer->data.data() + read_offset, size);
+  }
+  write_buffer->dirty = true;
+  return ensure_buffer_gpu(write_buffer) != nullptr || size == 0;
+}
+
+bool WebGLContext::get_buffer_sub_data(int target, uint32_t offset, uint8_t *out,
+                                       uint32_t size) {
+  WebGLBuffer *record = buffer(buffer_for_target(target));
+  if (record == nullptr || offset + size > record->data.size()) {
+    set_error(GL_INVALID_VALUE);
+    return false;
+  }
+  if (size > 0) memcpy(out, record->data.data() + offset, size);
+  return true;
+}
+
+SDL_GPUBuffer *WebGLContext::ensure_buffer_gpu(WebGLBuffer *buffer) {
+  if (buffer == nullptr || guidev::g_device == nullptr) return nullptr;
+  if (buffer->data.empty()) return nullptr;
+  end_pass();
+  ensure_command();
+  if (cmd_ == nullptr) return nullptr;
+  const uint32_t size = (uint32_t)buffer->data.size();
+  if (buffer->gpu == nullptr || buffer->capacity < size) {
+    if (buffer->gpu != nullptr) {
+      submit(); SDL_WaitForGPUIdle(guidev::g_device);
+      SDL_ReleaseGPUBuffer(guidev::g_device, buffer->gpu);
+    }
+    SDL_GPUBufferCreateInfo info;
+    memset(&info, 0, sizeof(info));
+    info.usage = SDL_GPU_BUFFERUSAGE_VERTEX | SDL_GPU_BUFFERUSAGE_INDEX;
+    info.size = size;
+    buffer->gpu = SDL_CreateGPUBuffer(guidev::g_device, &info);
+    buffer->capacity = size;
+    if (buffer->gpu == nullptr) {
+      set_error(GL_OUT_OF_MEMORY);
+      return nullptr;
+    }
+  }
+  if (buffer->dirty) {
+    /* Recreating the buffer above submitted the pending command buffer. */
+    ensure_command();
+    if (cmd_ == nullptr) return nullptr;
+    if (!upload_transfer(guidev::g_device, cmd_, buffer->gpu, buffer->data.data(), size)) {
+      set_error(GL_OUT_OF_MEMORY);
+      return nullptr;
+    }
+    buffer->dirty = false;
+  }
+  return buffer->gpu;
+}
+
+bool WebGLContext::buffer_data(uint32_t id, const uint8_t *bytes, uint32_t size, int usage) {
+  WebGLBuffer *record = buffer(id);
+  if (record == nullptr) {
+    set_error(GL_INVALID_OPERATION);
+    return false;
+  }
+  if (usage == GL_STREAM_DRAW || usage == GL_STATIC_DRAW || usage == GL_DYNAMIC_DRAW) {
+    record->usage = usage;
+  } else if (usage != 0) {
+    set_error(GL_INVALID_ENUM);
+    return false;
+  }
+  record->data.assign(size, 0);
+  if (bytes != nullptr && size > 0) memcpy(record->data.data(), bytes, size);
+  record->dirty = true;
+  return ensure_buffer_gpu(record) != nullptr || size == 0;
+}
+
+bool WebGLContext::buffer_sub_data(uint32_t id, uint32_t offset, const uint8_t *bytes,
+                                   uint32_t size) {
+  WebGLBuffer *record = buffer(id);
+  if (record == nullptr || offset > record->data.size() ||
+      offset + size > record->data.size()) {
+    set_error(GL_INVALID_VALUE);
+    return false;
+  }
+  memcpy(record->data.data() + offset, bytes, size);
+  record->dirty = true;
+  return ensure_buffer_gpu(record) != nullptr;
+}
+
+uint32_t WebGLContext::buffer_size(uint32_t id) {
+  WebGLBuffer *record = buffer(id);
+  return record != nullptr ? (uint32_t)record->data.size() : 0;
+}
+
+/* -- vertex attributes --------------------------------------------------- */
+
+void WebGLContext::enable_attrib(int index, bool enabled) {
+  if (index < 0 || index >= kWebGLMaxAttribs) {
+    set_error(GL_INVALID_VALUE);
+    return;
+  }
+  attribs_[index].enabled = enabled;
+}
+
+bool WebGLContext::attrib_enabled(int index) const {
+  return index >= 0 && index < kWebGLMaxAttribs && attribs_[index].enabled;
+}
+
+void WebGLContext::attrib_pointer(int index, int size, int type, bool normalized, int stride,
+                                  int offset) {
+  if (index < 0 || index >= kWebGLMaxAttribs) {
+    set_error(GL_INVALID_VALUE);
+    return;
+  }
+  WebGLAttribState &attrib = attribs_[index];
+  attrib.buffer = bound_array_;
+  attrib.size = size;
+  attrib.type = type;
+  attrib.normalized = normalized;
+  attrib.integer = false;
+  attrib.stride = stride > 0 ? stride : 0;
+  attrib.offset = offset;
+}
+
+void WebGLContext::attrib_ipointer(int index, int size, int type, int stride, int offset) {
+  if (index < 0 || index >= kWebGLMaxAttribs) {
+    set_error(GL_INVALID_VALUE);
+    return;
+  }
+  WebGLAttribState &attrib = attribs_[index];
+  attrib.buffer = bound_array_;
+  attrib.size = size;
+  attrib.type = type;
+  attrib.normalized = false;
+  attrib.integer = true;
+  attrib.stride = stride > 0 ? stride : 0;
+  attrib.offset = offset;
+}
+
+void WebGLContext::attrib_divisor(int index, int divisor) {
+  if (index < 0 || index >= kWebGLMaxAttribs) {
+    set_error(GL_INVALID_VALUE);
+    return;
+  }
+  /* SDL 3.2's `instance_step_rate` is reserved and must be 0, so only the two
+   * rates WebGL programs use — per vertex (0) and per instance (1) — map onto
+   * the backend. A larger divisor is clamped. */
+  attribs_[index].divisor = divisor > 0 ? 1 : 0;
+}
+
+void WebGLContext::attrib_value(int index, int components, const float *values) {
+  if (index < 0 || index >= kWebGLMaxAttribs) return;
+  for (int i = 0; i < 4; i++) attribs_[index].current[i] = i < components ? values[i] : 0.0f;
+  if (components < 4) attribs_[index].current[3] = 1.0f;
+}
+
+void WebGLContext::attrib_state(int index, int *size, int *type, int *stride, bool *normalized,
+                                float current[4]) const {
+  if (index < 0 || index >= kWebGLMaxAttribs) return;
+  const WebGLAttribState &attrib = attribs_[index];
+  *size = attrib.size;
+  *type = attrib.type;
+  *stride = attrib.stride;
+  *normalized = attrib.normalized;
+  for (int i = 0; i < 4; i++) current[i] = attrib.current[i];
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_clear.cpp

@@ -0,0 +1,142 @@
+/*
+ * xbintsc GUI engine — scissored clear.
+ *
+ * SDL_GPU render-pass clears ignore the scissor rectangle, but WebGL's `clear`
+ * honours it. A scissored colour clear is a blit from a 1×1 clear-colour
+ * texture into the scissor rectangle; depth and stencil are cleared by drawing
+ * a fullscreen triangle with colour writes masked off and depth/stencil writes
+ * enabled (depth test ALWAYS, stencil REPLACE).
+ *
+ * The internal program and buffer are ordinary engine objects, created lazily
+ * on the first scissored depth/stencil clear and kept for the context lifetime.
+ * The caller's state is saved and restored around the draw, so `clear` remains
+ * an API call that only changes the attachment contents.
+ */
+
+#include "webgl.h"
+
+#include <cstring>
+
+#include "gui_internal.h"
+
+namespace xtgui {
+namespace {
+
+const char *kClearVertexShader =
+    "attribute vec2 a_pos;\n"
+    "uniform float u_z;\n"
+    "void main() { gl_Position = vec4(a_pos, u_z, 1.0); }\n";
+
+const char *kClearFragmentShader =
+    "precision mediump float;\n"
+    "void main() { gl_FragColor = vec4(0.0); }\n";
+
+}  // namespace
+
+void WebGLContext::scissored_clear(int mask) {
+  if (guidev::g_device == nullptr) return;
+  const bool depth_bit = (mask & GL_DEPTH_BUFFER_BIT) != 0;
+  const bool stencil_bit = (mask & GL_STENCIL_BUFFER_BIT) != 0;
+  if (!depth_bit && !stencil_bit) return;
+
+  if (clear_program_ == 0) {
+    const uint32_t vs = create_shader(GL_VERTEX_SHADER);
+    shader_source(vs, kClearVertexShader);
+    const uint32_t fs = create_shader(GL_FRAGMENT_SHADER);
+    shader_source(fs, kClearFragmentShader);
+    if (compile_shader(vs) && compile_shader(fs)) {
+      const uint32_t program = create_program();
+      attach_shader(program, vs);
+      attach_shader(program, fs);
+      bind_attrib_location(program, 0, "a_pos");
+      if (link_program(program)) {
+        clear_program_ = program;
+      } else {
+        delete_program(program);
+      }
+    }
+    if (clear_program_ == 0) {
+      delete_shader(vs);
+      delete_shader(fs);
+    }
+  }
+  if (clear_program_ == 0) {
+    /* No shader backend: fall back to clearing the whole attachment rather than
+     * leaving the buffer untouched. */
+    begin_pass(false, depth_bit, stencil_bit);
+    return;
+  }
+  if (clear_buffer_ == 0) {
+    clear_buffer_ = create_buffer();
+    bind_buffer(GL_ARRAY_BUFFER, clear_buffer_);
+    const float vertices[6] = {-1.0f, -1.0f, 3.0f, -1.0f, -1.0f, 3.0f};
+    buffer_data(clear_buffer_, (const uint8_t *)vertices, (uint32_t)sizeof(vertices),
+                GL_DYNAMIC_DRAW);
+  }
+  if (clear_buffer_ == 0) {
+    begin_pass(false, depth_bit, stencil_bit);
+    return;
+  }
+
+  const WebGLDrawState saved_state = state_;
+  const uint32_t saved_program = current_program_;
+  const uint32_t saved_array = bound_array_;
+  int saved_viewport[4];
+  for (int i = 0; i < 4; i++) saved_viewport[i] = viewport_[i];
+  WebGLAttribState saved_attribs[kWebGLMaxAttribs];
+  memcpy(saved_attribs, attribs_, sizeof(attribs_));
+
+  state_.blend = false;
+  state_.cull = false;
+  for (bool &channel : state_.color_mask) channel = false;
+  state_.depth_test = depth_bit;
+  state_.depth_write = depth_bit;
+  state_.depth_func = GL_ALWAYS;
+  state_.stencil = stencil_bit;
+  if (stencil_bit) {
+    for (WebGLStencilFace *face : {&state_.stencil_front, &state_.stencil_back}) {
+      face->func = GL_ALWAYS;
+      face->ref = clear_stencil_;
+      face->value_mask = 0xFF;
+      face->write_mask = 0xFF;
+      face->fail = GL_KEEP;
+      face->zfail = GL_KEEP;
+      face->zpass = GL_REPLACE;
+    }
+  }
+  current_program_ = clear_program_;
+  int attrib = attrib_location(clear_program_, "a_pos");
+  if (attrib < 0 || attrib >= kWebGLMaxAttribs) attrib = 0;
+  attribs_[attrib] = WebGLAttribState();
+  attribs_[attrib].enabled = true;
+  attribs_[attrib].buffer = clear_buffer_;
+  attribs_[attrib].size = 2;
+  attribs_[attrib].type = GL_FLOAT;
+  attribs_[attrib].stride = 8;
+  attribs_[attrib].offset = 0;
+  int target_width = 0;
+  int target_height = 0;
+  framebuffer_size(bound_framebuffer_, &target_width, &target_height);
+  viewport_[0] = 0;
+  viewport_[1] = 0;
+  viewport_[2] = target_width;
+  viewport_[3] = target_height;
+
+  begin_pass(false, false, false);
+  if (pass_ != nullptr) {
+    const int z_location = uniform_location(clear_program_, "u_z");
+    if (z_location >= 0) {
+      const double depth = (double)clear_depth_;
+      uniform_floats(clear_program_, z_location, 1, &depth, 1);
+    }
+    draw_arrays(GL_TRIANGLES, 0, 3);
+  }
+
+  state_ = saved_state;
+  current_program_ = saved_program;
+  bound_array_ = saved_array;
+  memcpy(attribs_, saved_attribs, sizeof(attribs_));
+  for (int i = 0; i < 4; i++) viewport_[i] = saved_viewport[i];
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_compressed.cpp

@@ -0,0 +1,180 @@
+/*
+ * xbintsc GUI engine — compressed textures (S3TC/BC and ASTC).
+ *
+ * SDL_GPU exposes block-compressed formats directly, so the engine only has to
+ * map the WebGL extension enum to the SDL one and upload the tightly packed
+ * blocks. Compressed textures are sample-only and get a single mip level.
+ */
+
+#include "webgl.h"
+
+#include <cstring>
+
+#include "gui_internal.h"
+
+namespace xtgui {
+namespace {
+
+bool upload_compressed(SDL_GPUDevice *device, SDL_GPUCommandBuffer *cmd, SDL_GPUTexture *gpu,
+                       int x, int y, int width, int height, const uint8_t *data, uint32_t size) {
+  if (gpu == nullptr || data == nullptr || size == 0 || width <= 0 || height <= 0) return false;
+  SDL_GPUTransferBufferCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+  info.size = size;
+  SDL_GPUTransferBuffer *transfer = SDL_CreateGPUTransferBuffer(device, &info);
+  if (transfer == nullptr) return false;
+  void *mapped = SDL_MapGPUTransferBuffer(device, transfer, false);
+  if (mapped == nullptr) {
+    SDL_ReleaseGPUTransferBuffer(device, transfer);
+    return false;
+  }
+  memcpy(mapped, data, size);
+  SDL_UnmapGPUTransferBuffer(device, transfer);
+  SDL_GPUTextureTransferInfo source;
+  memset(&source, 0, sizeof(source));
+  source.transfer_buffer = transfer;
+  source.pixels_per_row = (Uint32)width;
+  source.rows_per_layer = (Uint32)height;
+  SDL_GPUTextureRegion region;
+  memset(&region, 0, sizeof(region));
+  region.texture = gpu;
+  region.x = (Uint32)x;
+  region.y = (Uint32)y;
+  region.w = (Uint32)width;
+  region.h = (Uint32)height;
+  region.d = 1;
+  SDL_GPUCopyPass *copy = SDL_BeginGPUCopyPass(cmd);
+  SDL_UploadToGPUTexture(copy, &source, &region, false);
+  SDL_EndGPUCopyPass(copy);
+  SDL_ReleaseGPUTransferBuffer(device, transfer);
+  return true;
+}
+
+}  // namespace
+
+SDL_GPUTextureFormat webgl_compressed_format(int internalformat) {
+  switch (internalformat) {
+    /* WEBGL_compressed_texture_s3tc */
+    case 0x83F0:  // COMPRESSED_RGB_S3TC_DXT1_EXT
+    case 0x83F1:  // COMPRESSED_RGBA_S3TC_DXT1_EXT
+      return SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM;
+    case 0x83F2:  // COMPRESSED_RGBA_S3TC_DXT3_EXT
+      return SDL_GPU_TEXTUREFORMAT_BC2_RGBA_UNORM;
+    case 0x83F3:  // COMPRESSED_RGBA_S3TC_DXT5_EXT
+      return SDL_GPU_TEXTUREFORMAT_BC3_RGBA_UNORM;
+    /* WEBGL_compressed_texture_s3tc_srgb */
+    case 0x8C4C:  // COMPRESSED_SRGB_S3TC_DXT1_EXT
+    case 0x8C4D:  // COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
+      return SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM_SRGB;
+    case 0x8C4E:  // COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
+      return SDL_GPU_TEXTUREFORMAT_BC2_RGBA_UNORM_SRGB;
+    case 0x8C4F:  // COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
+      return SDL_GPU_TEXTUREFORMAT_BC3_RGBA_UNORM_SRGB;
+    /* WEBGL_compressed_texture_astc (LDR) */
+    case 0x93B0:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_4x4_UNORM;
+    case 0x93B1:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_5x4_UNORM;
+    case 0x93B2:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_5x5_UNORM;
+    case 0x93B3:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_6x5_UNORM;
+    case 0x93B4:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_6x6_UNORM;
+    case 0x93B5:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_8x5_UNORM;
+    case 0x93B6:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_8x6_UNORM;
+    case 0x93B7:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_8x8_UNORM;
+    case 0x93B8:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_10x5_UNORM;
+    case 0x93B9:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_10x6_UNORM;
+    case 0x93BA:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_10x8_UNORM;
+    case 0x93BB:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_10x10_UNORM;
+    case 0x93BC:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_12x10_UNORM;
+    case 0x93BD:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_12x12_UNORM;
+    /* ASTC sRGB */
+    case 0x93D0:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_4x4_UNORM_SRGB;
+    case 0x93D1:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_5x4_UNORM_SRGB;
+    case 0x93D2:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_5x5_UNORM_SRGB;
+    case 0x93D3:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_6x5_UNORM_SRGB;
+    case 0x93D4:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_6x6_UNORM_SRGB;
+    case 0x93D5:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_8x5_UNORM_SRGB;
+    case 0x93D6:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_8x6_UNORM_SRGB;
+    case 0x93D7:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_8x8_UNORM_SRGB;
+    case 0x93D8:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_10x5_UNORM_SRGB;
+    case 0x93D9:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_10x6_UNORM_SRGB;
+    case 0x93DA:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_10x8_UNORM_SRGB;
+    case 0x93DB:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_10x10_UNORM_SRGB;
+    case 0x93DC:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_12x10_UNORM_SRGB;
+    case 0x93DD:
+      return SDL_GPU_TEXTUREFORMAT_ASTC_12x12_UNORM_SRGB;
+    default:
+      return SDL_GPU_TEXTUREFORMAT_INVALID;
+  }
+}
+
+bool WebGLContext::supports_texture_format(int internalformat) {
+  const SDL_GPUTextureFormat format = webgl_compressed_format(internalformat);
+  if (format == SDL_GPU_TEXTUREFORMAT_INVALID || guidev::g_device == nullptr) return false;
+  return SDL_GPUTextureSupportsFormat(guidev::g_device, format, SDL_GPU_TEXTURETYPE_2D,
+                                      SDL_GPU_TEXTUREUSAGE_SAMPLER);
+}
+
+bool WebGLContext::tex_image_compressed(uint32_t id, int width, int height,
+                                        SDL_GPUTextureFormat format, int x, int y,
+                                        int region_width, int region_height,
+                                        const uint8_t *data, uint32_t size) {
+  WebGLTexture *record = texture(id);
+  if (record == nullptr || width <= 0 || height <= 0 || format == SDL_GPU_TEXTUREFORMAT_INVALID) {
+    set_error(GL_INVALID_VALUE);
+    return false;
+  }
+  end_pass();
+  ensure_command();
+  if (cmd_ == nullptr) return false;
+  if (record->gpu != nullptr &&
+      (record->width != width || record->height != height || record->format != format ||
+       !record->compressed)) {
+    SDL_WaitForGPUIdle(guidev::g_device);
+    SDL_ReleaseGPUTexture(guidev::g_device, record->gpu);
+    record->gpu = nullptr;
+    record->usage = 0;
+  }
+  record->width = width;
+  record->height = height;
+  record->format = format;
+  record->depth = false;
+  record->compressed = true;
+  record->has_mipmaps = false;
+  if (record->sampler != nullptr) {
+    SDL_ReleaseGPUSampler(guidev::g_device, record->sampler);
+    record->sampler = nullptr;
+  }
+  if (ensure_texture_gpu(record, false) == nullptr) return false;
+  record->defined = true;
+  return upload_compressed(guidev::g_device, cmd_, record->gpu, x, y, region_width, region_height,
+                           data, size);
+}
+
+}  // namespace xtgui