xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/webgl_state.cpp

@@ -0,0 +1,228 @@
+/*
+ * xbintsc GUI engine — WebGL fixed-function state.
+ *
+ * SDL_GPU bakes blend/depth/stencil/rasterisation into a pipeline, so these
+ * setters only record the values; `webgl_draw.cpp` hashes them into the
+ * pipeline cache key and `webgl_pipeline.cpp` builds the matching state.
+ */
+
+#include "webgl.h"
+
+#include <algorithm>
+#include <cstring>
+
+#include "gui_internal.h"
+
+namespace xtgui {
+
+/* -- 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) state_.stencil = 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) state_.stencil = 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 state_.stencil;
+  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::blend_color(float r, float g, float b, float a) {
+  blend_color_[0] = r;
+  blend_color_[1] = g;
+  blend_color_[2] = b;
+  blend_color_[3] = a;
+}
+
+void WebGLContext::blend_color_value(float out[4]) const {
+  for (int i = 0; i < 4; i++) out[i] = blend_color_[i];
+}
+
+void WebGLContext::cull_face(int mode) { state_.cull_face = mode; }
+
+void WebGLContext::front_face(int mode) { state_.front_face = mode; }
+
+void WebGLContext::stencil_func(int func, int ref, uint32_t mask) {
+  stencil_func_separate(GL_FRONT_AND_BACK, func, ref, mask);
+}
+
+void WebGLContext::stencil_func_separate(int face, int func, int ref, uint32_t mask) {
+  if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
+    state_.stencil_front.func = func;
+    state_.stencil_front.ref = ref;
+    state_.stencil_front.value_mask = mask;
+  }
+  if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
+    state_.stencil_back.func = func;
+    state_.stencil_back.ref = ref;
+    state_.stencil_back.value_mask = mask;
+  }
+}
+
+void WebGLContext::stencil_op(int fail, int zfail, int zpass) {
+  stencil_op_separate(GL_FRONT_AND_BACK, fail, zfail, zpass);
+}
+
+void WebGLContext::stencil_op_separate(int face, int fail, int zfail, int zpass) {
+  if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
+    state_.stencil_front.fail = fail;
+    state_.stencil_front.zfail = zfail;
+    state_.stencil_front.zpass = zpass;
+  }
+  if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
+    state_.stencil_back.fail = fail;
+    state_.stencil_back.zfail = zfail;
+    state_.stencil_back.zpass = zpass;
+  }
+}
+
+void WebGLContext::stencil_mask(uint32_t mask) {
+  stencil_mask_separate(GL_FRONT_AND_BACK, mask);
+}
+
+void WebGLContext::stencil_mask_separate(int face, uint32_t mask) {
+  if (face == GL_FRONT || face == GL_FRONT_AND_BACK) state_.stencil_front.write_mask = mask;
+  if (face == GL_BACK || face == GL_FRONT_AND_BACK) state_.stencil_back.write_mask = mask;
+}
+
+const WebGLStencilFace &WebGLContext::stencil_face(int face) const {
+  return face == GL_FRONT ? state_.stencil_front : state_.stencil_back;
+}
+
+int WebGLContext::stencil_reference() const {
+  /* SDL_GPU has one stencil reference for a draw; the front value is the
+   * WebGL default for both faces. */
+  return state_.stencil_front.ref;
+}
+
+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;
+  const bool stencil_bit = (mask & GL_STENCIL_BUFFER_BIT) != 0;
+  const bool scissored = scissor_test_ && scissor_box_[2] > 0 && scissor_box_[3] > 0;
+  if (!scissored) {
+    begin_pass(color_bit, depth_bit, stencil_bit);
+    return;
+  }
+  if (color_bit) {
+    SDL_GPUTexture *source = clear_color_texture();
+    SDL_GPUTexture *destination = target_color();
+    int target_width = 0;
+    int target_height = 0;
+    framebuffer_size(bound_framebuffer_, &target_width, &target_height);
+    if (source != nullptr && destination != nullptr && target_width > 0 && target_height > 0) {
+      end_pass();
+      ensure_command();
+      if (cmd_ != nullptr) {
+        int x = std::max(0, scissor_box_[0]);
+        int y = std::max(0, scissor_box_[1]);
+        int w = scissor_box_[2];
+        int h = scissor_box_[3];
+        if (x + w > target_width) w = target_width - x;
+        if (y + h > target_height) h = target_height - y;
+        if (w > 0 && h > 0) {
+          SDL_GPUBlitRegion source_region;
+          memset(&source_region, 0, sizeof(source_region));
+          source_region.texture = source;
+          source_region.w = 1;
+          source_region.h = 1;
+                  SDL_GPUBlitRegion destination_region;
+          memset(&destination_region, 0, sizeof(destination_region));
+          destination_region.texture = destination;
+          destination_region.x = (Uint32)x;
+          destination_region.y = (Uint32)(target_height - (y + h));
+          destination_region.w = (Uint32)w;
+          destination_region.h = (Uint32)h;
+                  SDL_GPUBlitInfo info;
+          memset(&info, 0, sizeof(info));
+          info.source = source_region;
+          info.destination = destination_region;
+          /* The pixels outside the scissor rectangle must survive the clear, so
+           * the blit has to load the destination. DONT_CARE maps to Metal's
+           * MTLLoadActionDontCare, which discards the whole attachment before
+           * the blit writes its region and leaves the rest undefined (Vulkan
+           * happened to preserve it, which hid this in CI on Linux). */
+          info.load_op = SDL_GPU_LOADOP_LOAD;
+          info.filter = SDL_GPU_FILTER_NEAREST;
+          SDL_BlitGPUTexture(cmd_, &info);
+        }
+      }
+    }
+  }
+  if (depth_bit || stencil_bit) scissored_clear(mask);
+}
+
+void WebGLContext::finish() {
+  submit();
+  if (guidev::g_device != nullptr) SDL_WaitForGPUIdle(guidev::g_device);
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_texture.cpp

@@ -12,16 +12,31 @@
 namespace xtgui {
 namespace {
 
-/** Upload an RGBA8 rectangle into level 0 of `gpu`. `rgba` may be null, which
- * uploads transparent black. */
+bool depth_texture_format(SDL_GPUTextureFormat format) {
+  return format == SDL_GPU_TEXTUREFORMAT_D16_UNORM ||
+         format == SDL_GPU_TEXTUREFORMAT_D24_UNORM ||
+         format == SDL_GPU_TEXTUREFORMAT_D32_FLOAT ||
+         format == SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT ||
+         format == SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
+}
+
+int texel_bytes(SDL_GPUTextureFormat format) {
+  if (format == SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT) return 8;
+  if (format == SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT) return 16;
+  return 4;
+}
+
+/** Upload a rectangle of tightly packed texels into level 0 of `gpu`. `pixels`
+ * may be null, which uploads zeros. */
 bool upload_region(SDL_GPUDevice *device, SDL_GPUCommandBuffer *cmd, SDL_GPUTexture *gpu, int x,
-                   int y, int width, int height, const uint8_t *rgba) {
-  const uint32_t bytes = (uint32_t)(width * height * 4);
+                   int y, int width, int height, const uint8_t *pixels, int bytes_per_texel,
+                   int layer = 0) {
+  const uint32_t bytes = (uint32_t)(width * height * bytes_per_texel);
   if (bytes == 0) return true;
   std::vector<uint8_t> zeros;
-  if (rgba == nullptr) {
+  if (pixels == nullptr) {
     zeros.assign(bytes, 0);
-    rgba = zeros.data();
+    pixels = zeros.data();
   }
   SDL_GPUTransferBufferCreateInfo info;
   memset(&info, 0, sizeof(info));
@@ -34,7 +49,7 @@ bool upload_region(SDL_GPUDevice *device, SDL_GPUCommandBuffer *cmd, SDL_GPUText
     SDL_ReleaseGPUTransferBuffer(device, transfer);
     return false;
   }
-  memcpy(mapped, rgba, bytes);
+  memcpy(mapped, pixels, bytes);
   SDL_UnmapGPUTransferBuffer(device, transfer);
   SDL_GPUTextureTransferInfo source;
   memset(&source, 0, sizeof(source));
@@ -46,6 +61,7 @@ bool upload_region(SDL_GPUDevice *device, SDL_GPUCommandBuffer *cmd, SDL_GPUText
   region.texture = gpu;
   region.x = (Uint32)x;
   region.y = (Uint32)y;
+  region.layer = (Uint32)layer;
   region.w = (Uint32)width;
   region.h = (Uint32)height;
   region.d = 1;
@@ -58,7 +74,44 @@ bool upload_region(SDL_GPUDevice *device, SDL_GPUCommandBuffer *cmd, SDL_GPUText
 
 }  // namespace
 
-bool WebGLContext::tex_image_rgba(uint32_t id, int width, int height, const uint8_t *rgba) {
+SDL_GPUTexture *WebGLContext::clear_color_texture() {
+  if (guidev::g_device == nullptr) return nullptr;
+  if (clear_texture_ == nullptr) {
+    end_pass();
+    ensure_command();
+    SDL_GPUTextureCreateInfo info;
+    memset(&info, 0, sizeof(info));
+    info.type = SDL_GPU_TEXTURETYPE_2D;
+    info.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+    info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER | SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
+    info.width = 1;
+    info.height = 1;
+    info.layer_count_or_depth = 1;
+    info.num_levels = 1;
+    info.sample_count = SDL_GPU_SAMPLECOUNT_1;
+    clear_texture_ = SDL_CreateGPUTexture(guidev::g_device, &info);
+    if (clear_texture_ == nullptr) {
+      set_error(GL_OUT_OF_MEMORY);
+      return nullptr;
+    }
+  }
+  end_pass();
+  ensure_command();
+  if (cmd_ == nullptr) return clear_texture_;
+  uint8_t rgba[4];
+  for (int i = 0; i < 4; i++) {
+    float value = clear_color_[i];
+    if (value < 0.0f) value = 0.0f;
+    if (value > 1.0f) value = 1.0f;
+    rgba[i] = (uint8_t)(value * 255.0f + 0.5f);
+  }
+  upload_region(guidev::g_device, cmd_, clear_texture_, 0, 0, 1, 1, rgba, 4);
+  return clear_texture_;
+}
+
+bool WebGLContext::tex_image_format(uint32_t id, int width, int height,
+                                    SDL_GPUTextureFormat format, const uint8_t *pixels,
+                                    int layer) {
   WebGLTexture *record = texture(id);
   if (record == nullptr || width <= 0 || height <= 0) {
     set_error(GL_INVALID_VALUE);
@@ -67,27 +120,43 @@ bool WebGLContext::tex_image_rgba(uint32_t id, int width, int height, const uint
   end_pass();
   ensure_command();
   if (cmd_ == nullptr) return false;
-  if (record->width != width || record->height != height) {
+  if (record->width != width || record->height != height || record->format != format) {
     if (record->gpu != nullptr) {
       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->layers = 1;
+    record->target = layer >= 0 ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D;
+    record->compressed = false;
     record->has_mipmaps = false;
     if (record->sampler != nullptr) {
       SDL_ReleaseGPUSampler(guidev::g_device, record->sampler);
       record->sampler = nullptr;
     }
   }
-  if (ensure_texture_gpu(record, record->as_target) == nullptr) return false;
+  if (ensure_texture_gpu(record, record->as_target || record->as_depth_target) == nullptr) {
+    return false;
+  }
   record->defined = true;
-  return upload_region(guidev::g_device, cmd_, record->gpu, 0, 0, width, height, rgba);
+  if (layer >= 0) {
+    record->target = GL_TEXTURE_CUBE_MAP;
+    record->layers = 6;
+  }
+  return upload_region(guidev::g_device, cmd_, record->gpu, 0, 0, width, height, pixels,
+                       texel_bytes(format), layer >= 0 ? layer : 0);
 }
 
-bool WebGLContext::tex_sub_image_rgba(uint32_t id, int x, int y, int width, int height,
-                                      const uint8_t *rgba) {
+bool WebGLContext::tex_image_rgba(uint32_t id, int width, int height, const uint8_t *rgba) {
+  return tex_image_format(id, width, height, SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, rgba);
+}
+
+bool WebGLContext::tex_sub_image_format(uint32_t id, int x, int y, int width, int height,
+                                        const uint8_t *pixels, int layer) {
   WebGLTexture *record = texture(id);
   if (record == nullptr || !record->defined || record->gpu == nullptr) {
     set_error(GL_INVALID_OPERATION);
@@ -101,7 +170,13 @@ bool WebGLContext::tex_sub_image_rgba(uint32_t id, int x, int y, int width, int
   end_pass();
   ensure_command();
   if (cmd_ == nullptr) return false;
-  return upload_region(guidev::g_device, cmd_, record->gpu, x, y, width, height, rgba);
+  return upload_region(guidev::g_device, cmd_, record->gpu, x, y, width, height, pixels,
+                       texel_bytes(record->format), layer);
+}
+
+bool WebGLContext::tex_sub_image_rgba(uint32_t id, int x, int y, int width, int height,
+                                      const uint8_t *rgba) {
+  return tex_sub_image_format(id, x, y, width, height, rgba);
 }
 
 bool WebGLContext::generate_mipmap(uint32_t id) {
@@ -110,6 +185,11 @@ bool WebGLContext::generate_mipmap(uint32_t id) {
     set_error(GL_INVALID_OPERATION);
     return false;
   }
+  if (record->depth) {
+    /* Depth textures have no mip chain in this backend. */
+    set_error(GL_INVALID_OPERATION);
+    return false;
+  }
   end_pass();
   ensure_command();
   if (cmd_ == nullptr || record->levels <= 1) return false;
@@ -124,7 +204,25 @@ bool WebGLContext::generate_mipmap(uint32_t id) {
 
 bool WebGLContext::read_pixels(int x, int y, int width, int height, uint8_t *out) {
   if (out == nullptr || width <= 0 || height <= 0) return false;
+  if (target_color_format() != (int)SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM) {
+    /* The only readback this surface offers is RGBA8; a float/half colour
+     * target is read by rendering it into an RGBA8 target instead. */
+    set_error(GL_INVALID_OPERATION);
+    return false;
+  }
   SDL_GPUTexture *target = target_color();
+  if (bound_framebuffer_ != 0) {
+    WebGLFramebuffer *framebuffer = this->framebuffer(bound_framebuffer_);
+    if (framebuffer != nullptr) {
+      int index = read_buffer_ - GL_COLOR_ATTACHMENT0;
+      if (index < 0 || index >= kWebGLMaxDrawBuffers ||
+          framebuffer->color_textures[index] == 0) {
+        index = 0;
+      }
+      WebGLTexture *read_texture = texture(framebuffer->color_textures[index]);
+      target = read_texture != nullptr ? ensure_texture_gpu(read_texture, true) : nullptr;
+    }
+  }
   int target_width = bound_framebuffer_ == 0 ? width_ : 0;
   int target_height = bound_framebuffer_ == 0 ? height_ : 0;
   if (bound_framebuffer_ != 0) {
@@ -196,7 +294,8 @@ bool WebGLContext::read_pixels(int x, int y, int width, int height, uint8_t *out
   return true;
 }
 
-bool WebGLContext::tex_storage_2d(uint32_t id, int levels, int width, int height) {
+bool WebGLContext::tex_storage_format(uint32_t id, int levels, int width, int height,
+                                      SDL_GPUTextureFormat format) {
   (void)levels;  // the backend always allocates the full mip chain
   WebGLTexture *record = texture(id);
   if (record == nullptr || width <= 0 || height <= 0) {
@@ -210,20 +309,29 @@ bool WebGLContext::tex_storage_2d(uint32_t id, int levels, int width, int height
     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->layers = 1;
+  record->target = GL_TEXTURE_2D;
+  record->compressed = false;
   record->has_mipmaps = false;
   if (record->sampler != nullptr && guidev::g_device != nullptr) {
     SDL_ReleaseGPUSampler(guidev::g_device, record->sampler);
     record->sampler = nullptr;
   }
   record->defined = true;
-  return ensure_texture_gpu(record, record->as_target) != nullptr;
+  return ensure_texture_gpu(record, record->as_target || record->as_depth_target) != nullptr;
 }
 
-/* -- WebGL 2 clearBuffer* ------------------------------------------------ */
+bool WebGLContext::tex_storage_2d(uint32_t id, int levels, int width, int height) {
+  return tex_storage_format(id, levels, width, height,
+                            SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM);
+}
 
+/* -- WebGL 2 clearBuffer* ------------------------------------------------ */
 void WebGLContext::clear_buffer_float(int buffer, int drawbuffer, const float *values,
                                       int count) {
   if (buffer == GL_COLOR) {
@@ -290,4 +398,23 @@ void WebGLContext::clear_buffer_fi(int buffer, int drawbuffer, float depth, int
   }
 }
 
+SDL_GPUTextureFormat webgl_storage_format(int internalformat) {
+  if (internalformat == GL_DEPTH_COMPONENT16 || internalformat == GL_DEPTH_COMPONENT24 ||
+      internalformat == GL_DEPTH_COMPONENT32F) {
+    return SDL_GPU_TEXTUREFORMAT_D32_FLOAT;
+  }
+  if (internalformat == GL_DEPTH_STENCIL || internalformat == GL_DEPTH24_STENCIL8) {
+    return SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
+  }
+  if (internalformat == GL_RGBA32F || internalformat == GL_RGB32F ||
+      internalformat == GL_RG32F || internalformat == GL_R32F) {
+    return SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT;
+  }
+  if (internalformat == GL_RGBA16F || internalformat == GL_RGB16F ||
+      internalformat == GL_RG16F || internalformat == GL_R16F) {
+    return SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT;
+  }
+  return SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+}
+
 }  // namespace xtgui