xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/dom_api_style.cpp

@@ -51,17 +51,18 @@ static void write_declarations(xtgui::Node *node, const std::vector<xtgui::Decla
 }
 
 static void set_style_property(XtGuiWindow *win, xtgui::Node *node, const std::string &name,
-                               const std::string &value) {
+                               const std::string &value, bool important) {
   std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
   bool found = false;
   for (xtgui::Declaration &decl : decls) {
     if (decl.property == name) {
       decl.value = value;
-      decl.important = false;
+      decl.important = important;
       found = true;
+      break;
     }
   }
-  if (!found) decls.push_back({name, value, false});
+  if (!found) decls.push_back({name, value, important});
   write_declarations(node, decls);
   mark_dirty(win);
 }
@@ -75,6 +76,26 @@ static std::string get_style_property(const xtgui::Node *node, const std::string
   return value;
 }
 
+static std::string get_style_priority(const xtgui::Node *node, const std::string &name) {
+  std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
+  for (const xtgui::Declaration &decl : decls) {
+    if (decl.property == name) return decl.important ? "important" : "";
+  }
+  return "";
+}
+
+static std::string serialize_declarations(const xtgui::Node *node) {
+  std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
+  std::string out;
+  for (const xtgui::Declaration &decl : decls) {
+    if (!out.empty()) out += " ";
+    out += decl.property + ": " + decl.value;
+    if (decl.important) out += " !important";
+    out += ";";
+  }
+  return out;
+}
+
 static void remove_style_property(XtGuiWindow *win, xtgui::Node *node, const std::string &name) {
   std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
   std::vector<xtgui::Declaration> kept;
@@ -133,17 +154,36 @@ METHOD(class_list_toggle) {
   xtgui::Node *node = class_list_node(self, &win);
   if (node == nullptr || argc < 1) return XT_FALSE;
   std::string name = to_string_value(xt_arg(argc, argv, 0));
+  if (name.empty()) return XT_FALSE;
   std::vector<std::string> names = split_classes(class_name_of(node));
   auto it = std::find(names.begin(), names.end(), name);
-  if (it != names.end()) {
-    names.erase(it);
-    set_class_name(win, node, join_classes(names));
+  bool present = it != names.end();
+  /* `toggle(name, force)`: with `force` the call is idempotent — it adds when
+   * the second argument is truthy and removes when it is falsy, instead of
+   * flipping. The argument is optional, so `undefined` still means "flip". */
+  bool forceProvided = argc >= 2 && !XT_IS_UNDEFINED(xt_arg(argc, argv, 1));
+  bool force = forceProvided && value_truthy(xt_arg(argc, argv, 1));
+  if (forceProvided) {
+    if (force) {
+      if (!present) {
+        names.push_back(name);
+        set_class_name(win, node, join_classes(names));
+      }
+      return XT_TRUE;
+    }
+    if (present) {
+      names.erase(it);
+      set_class_name(win, node, join_classes(names));
+    }
     return XT_FALSE;
   }
-  if (!name.empty()) {
-    names.push_back(name);
+  if (present) {
+    names.erase(it);
     set_class_name(win, node, join_classes(names));
+    return XT_FALSE;
   }
+  names.push_back(name);
+  set_class_name(win, node, join_classes(names));
   return XT_TRUE;
 }
 
@@ -165,8 +205,19 @@ METHOD(style_set_property) {
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = style_node(self, &win);
   if (node == nullptr || argc < 2) return XT_UNDEFINED;
-  set_style_property(win, node, to_string_value(xt_arg(argc, argv, 0)),
-                     to_string_value(xt_arg(argc, argv, 1)));
+  std::string name = xtgui::xt_css_lower(xtgui::xt_css_trim(to_string_value(xt_arg(argc, argv, 0))));
+  if (name.empty()) return XT_UNDEFINED;
+  /* `priority` is "" or "important"; any other value makes the whole call a
+   * no-op, exactly as in the CSSOM. */
+  std::string priority;
+  if (argc >= 3) priority = xtgui::xt_css_lower(xtgui::xt_css_trim(to_string_value(xt_arg(argc, argv, 2))));
+  if (!priority.empty() && priority != "important") return XT_UNDEFINED;
+  std::string value = to_string_value(xt_arg(argc, argv, 1));
+  if (xtgui::xt_css_trim(value).empty()) {
+    remove_style_property(win, node, name);
+    return XT_UNDEFINED;
+  }
+  set_style_property(win, node, name, value, priority == "important");
   return XT_UNDEFINED;
 }
 
@@ -175,18 +226,177 @@ METHOD(style_get_property_value) {
   xtgui::Node *node = style_node(self, nullptr);
   if (node == nullptr || argc < 1) return xt_string_from_cstr("");
   return xt_string_from_cstr(
-      get_style_property(node, to_string_value(xt_arg(argc, argv, 0))).c_str());
+      get_style_property(node, xtgui::xt_css_lower(xtgui::xt_css_trim(to_string_value(xt_arg(argc, argv, 0)))))
+          .c_str());
+}
+
+METHOD(style_get_property_priority) {
+  (void)env;
+  xtgui::Node *node = style_node(self, nullptr);
+  if (node == nullptr || argc < 1) return xt_string_from_cstr("");
+  return xt_string_from_cstr(
+      get_style_priority(node, xtgui::xt_css_lower(xtgui::xt_css_trim(to_string_value(xt_arg(argc, argv, 0)))))
+          .c_str());
 }
 
 METHOD(style_remove_property) {
   (void)env;
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = style_node(self, &win);
-  if (node == nullptr || argc < 1) return XT_UNDEFINED;
-  remove_style_property(win, node, to_string_value(xt_arg(argc, argv, 0)));
+  if (node == nullptr || argc < 1) return xt_string_from_cstr("");
+  std::string name = xtgui::xt_css_lower(xtgui::xt_css_trim(to_string_value(xt_arg(argc, argv, 0))));
+  std::string previous = get_style_property(node, name);
+  remove_style_property(win, node, name);
+  return xt_string_from_cstr(previous.c_str());
+}
+
+METHOD(style_css_text_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = style_node(self, nullptr);
+  if (node == nullptr) return xt_string_from_cstr("");
+  return xt_string_from_cstr(serialize_declarations(node).c_str());
+}
+
+METHOD(style_css_text_set) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = style_node(self, &win);
+  if (node == nullptr) return XT_UNDEFINED;
+  std::vector<xtgui::Declaration> decls =
+      xtgui::xt_css_parse_declarations(to_string_value(xt_arg(argc, argv, 0)));
+  write_declarations(node, decls);
+  mark_dirty(win);
   return XT_UNDEFINED;
 }
 
+/* -- named properties (`style.width = "50%"`) -----------------------------
+ *
+ * A CSSStyleDeclaration exposes every supported CSS property as a camel-cased
+ * property (`style.width`, `style.backgroundColor`) as well as through
+ * `setProperty`. There are hundreds of them, so instead of enumerating
+ * accessors the style object installs the runtime's dynamic-property hooks:
+ * a miss on the prototype is answered from the inline declaration block, and
+ * an assignment writes it back there. That is what makes the common
+ * `el.style.display = "none"` idiom affect layout instead of silently parking
+ * a field on the JS object.
+ */
+
+namespace {
+
+bool property_key(xt_value key, std::string *out) {
+  if (!XT_IS_STRING(key)) return false;
+  /* Named style properties are camel-cased (`style.backgroundColor`); the
+   * declaration block stores the CSS spelling (`background-color`). Custom
+   * properties keep their leading `--`, and internal bookkeeping keys stay
+   * out of the view (looking one up must not re-enter it). */
+  std::string raw = to_string_value(key);
+  if (raw.compare(0, 6, "__xt_") == 0) return false;
+  std::string mapped;
+  for (char c : raw) {
+    if (c >= 'A' && c <= 'Z') {
+      mapped.push_back('-');
+      mapped.push_back((char)std::tolower((unsigned char)c));
+    } else {
+      mapped.push_back(c);
+    }
+  }
+  *out = xtgui::xt_css_lower(xtgui::xt_css_trim(mapped));
+  return !out->empty();
+}
+
+xt_value style_view_get(xt_value self, xt_value key, void *data) {
+  (void)data;
+  std::string name;
+  if (!property_key(key, &name)) return XT_UNDEFINED;
+  xtgui::Node *node = style_node(self, nullptr);
+  if (node == nullptr) return xt_string_from_cstr("");
+  return xt_string_from_cstr(get_style_property(node, name).c_str());
+}
+
+int style_view_set(xt_value self, xt_value key, xt_value value, void *data) {
+  (void)data;
+  std::string name;
+  if (!property_key(key, &name)) return 0;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = style_node(self, &win);
+  if (node == nullptr) return 1;
+  std::string text = to_string_value(value);
+  if (text.empty()) {
+    remove_style_property(win, node, name);
+  } else {
+    set_style_property(win, node, name, text, false);
+  }
+  return 1;
+}
+
+int style_view_has(xt_value self, xt_value key, void *data) {
+  (void)data;
+  std::string name;
+  if (!property_key(key, &name)) return 0;
+  xtgui::Node *node = style_node(self, nullptr);
+  if (node == nullptr) return 0;
+  std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
+  for (const xtgui::Declaration &decl : decls) {
+    if (decl.property == name) return 1;
+  }
+  return 0;
+}
+
+int style_view_remove(xt_value self, xt_value key, void *data) {
+  (void)data;
+  std::string name;
+  if (!property_key(key, &name)) return 0;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = style_node(self, &win);
+  if (node == nullptr) return 1;
+  remove_style_property(win, node, name);
+  return 1;
+}
+
+xt_value style_view_keys(xt_value self, void *data) {
+  (void)data;
+  xtgui::Node *node = style_node(self, nullptr);
+  xt_value result = xt_array_new(0, nullptr);
+  if (node == nullptr) return result;
+  std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
+  for (const xtgui::Declaration &decl : decls) {
+    xt_array_push(result, xt_string_from_cstr(decl.property.c_str()));
+  }
+  return result;
+}
+
+const xt_object_hooks kStyleViewHooks = {style_view_get, style_view_set, style_view_has,
+                                         style_view_remove, style_view_keys};
+
+}  // namespace
+
+void install_style_hooks(xt_value style) {
+  xt_object_set_hooks(style, &kStyleViewHooks, nullptr);
+}
+
+METHOD(style_length_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Node *node = style_node(self, nullptr);
+  if (node == nullptr) return xt_number(0);
+  return xt_number(
+      (double)xtgui::xt_css_parse_declarations(inline_style_of(node)).size());
+}
+
+/** `style.item(index)`: the property name at `index`, or "" past the end. */
+METHOD(style_item) {
+  (void)env;
+  xtgui::Node *node = style_node(self, nullptr);
+  if (node == nullptr || argc < 1) return xt_string_from_cstr("");
+  std::vector<xtgui::Declaration> decls = xtgui::xt_css_parse_declarations(inline_style_of(node));
+  double index = xt_to_number(xt_arg(argc, argv, 0));
+  if (index < 0 || index >= (double)decls.size()) return xt_string_from_cstr("");
+  return xt_string_from_cstr(decls[(size_t)index].property.c_str());
+}
+
 #undef METHOD
 
 }  // namespace domapi

package/runtime/ext_gui/dom_api_webgl.cpp

@@ -159,6 +159,8 @@ const MethodEntry kMethods[] = {
     {"getTexParameter", (void *)webgl_get_tex_parameter},
     {"texImage2D", (void *)webgl_tex_image_2d},
     {"texSubImage2D", (void *)webgl_tex_sub_image_2d},
+    {"compressedTexImage2D", (void *)webgl_compressed_tex_image_2d},
+    {"compressedTexSubImage2D", (void *)webgl_compressed_tex_sub_image_2d},
     {"generateMipmap", (void *)webgl_generate_mipmap},
     {"createFramebuffer", (void *)webgl_create_framebuffer},
     {"deleteFramebuffer", (void *)webgl_delete_framebuffer},
@@ -238,6 +240,11 @@ xtgui::WebGLContext *webgl_from_context(xt_value self) {
   return id != 0 ? xtgui::xt_webgl_by_id(id) : nullptr;
 }
 
+xtgui::WebGLContext *webgl_live_context(xt_value self) {
+  xtgui::WebGLContext *context = webgl_from_context(self);
+  return context != nullptr && !context->lost() ? context : nullptr;
+}
+
 xt_value webgl_context_handle(xt_value element, xtgui::WebGLContext *context) {
   xt_value cached = xt_object_get_cstr(element, "__xt_gui_gl");
   if (XT_IS_OBJECT(cached)) return cached;

package/runtime/ext_gui/dom_api_webgl2.cpp

@@ -81,12 +81,13 @@ const MethodEntry kMethods[] = {
     {"getActiveUniformBlockParameter", (void *)webgl2_get_active_uniform_block_parameter},
     {"getActiveUniformBlockName", (void *)webgl2_get_active_uniform_block_name},
     {"uniformBlockBinding", (void *)webgl2_uniform_block_binding},
+    {"drawingBufferStorage", (void *)webgl2_drawing_buffer_storage},
     {"texStorage2D", (void *)webgl2_tex_storage_2d},
     {"texStorage3D", (void *)webgl2_tex_storage_3d},
     {"texImage3D", (void *)webgl2_tex_image_3d},
     {"texSubImage3D", (void *)webgl2_tex_sub_image_3d},
-    {"compressedTexImage2D", (void *)webgl2_compressed_tex_image2d},
-    {"compressedTexSubImage2D", (void *)webgl2_compressed_tex_sub_image2d},
+    {"compressedTexImage2D", (void *)webgl_compressed_tex_image_2d},
+    {"compressedTexSubImage2D", (void *)webgl_compressed_tex_sub_image_2d},
     {"compressedTexImage3D", (void *)webgl2_compressed_tex_image3d},
     {"compressedTexSubImage3D", (void *)webgl2_compressed_tex_sub_image3d},
     {"clearBufferfi", (void *)webgl2_clear_buffer_fi},
@@ -107,7 +108,7 @@ void define_method(xt_value proto, const char *name, void *fn) {
   xt_object_set(proto, xt_string_from_cstr(name), xt_closure_new(fn, 0, NULL));
 }
 
-xtgui::WebGLContext *context_of(xt_value self) { return webgl_from_context(self); }
+xtgui::WebGLContext *context_of(xt_value self) { return webgl_live_context(self); }
 
 xt_value uint_array(const unsigned int *values, int count) {
   xt_value array = xt_array_new(0, nullptr);
@@ -202,14 +203,66 @@ WEBGL2_NOOP(webgl2_end_transform_feedback)
 WEBGL2_NOOP(webgl2_pause_transform_feedback)
 WEBGL2_NOOP(webgl2_resume_transform_feedback)
 WEBGL2_NOOP(webgl2_transform_feedback_varyings)
-WEBGL2_NOOP(webgl2_bind_buffer_base)
-WEBGL2_NOOP(webgl2_bind_buffer_range)
-WEBGL2_NOOP(webgl2_uniform_block_binding)
-WEBGL2_NOOP(webgl2_blit_framebuffer)
-WEBGL2_NOOP(webgl2_framebuffer_texture_layer)
 WEBGL2_NOOP(webgl2_invalidate_framebuffer)
 WEBGL2_NOOP(webgl2_invalidate_sub_framebuffer)
-WEBGL2_NOOP(webgl2_read_buffer)
+
+METHOD(webgl2_blit_framebuffer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const int source[4] = {webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0),
+                         webgl_int(argc, argv, 2, 0), webgl_int(argc, argv, 3, 0)};
+  const int destination[4] = {webgl_int(argc, argv, 4, 0), webgl_int(argc, argv, 5, 0),
+                              webgl_int(argc, argv, 6, 0), webgl_int(argc, argv, 7, 0)};
+  context->blit_framebuffer(source, destination, webgl_int(argc, argv, 8, GL_COLOR_BUFFER_BIT),
+                            webgl_int(argc, argv, 9, GL_NEAREST));
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_tex_sub_image_3d) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const uint32_t texture = context->bound_texture(0);
+  if (texture == 0 || webgl_int(argc, argv, 1, 0) != 0) return XT_UNDEFINED;
+  const int x = webgl_int(argc, argv, 2, 0);
+  const int y = webgl_int(argc, argv, 3, 0);
+  const int z = webgl_int(argc, argv, 4, 0);
+  const int width = webgl_int(argc, argv, 5, 0);
+  const int height = webgl_int(argc, argv, 6, 0);
+  const int depth = webgl_int(argc, argv, 7, 0);
+  const int format = webgl_int(argc, argv, 8, GL_RGBA);
+  const int type = webgl_int(argc, argv, 9, GL_UNSIGNED_BYTE);
+  if (type != GL_UNSIGNED_BYTE) {
+    context->set_error(GL_INVALID_ENUM);
+    return XT_UNDEFINED;
+  }
+  int channels = 1;
+  if (format == GL_RGBA) channels = 4;
+  else if (format == GL_RGB) channels = 3;
+  else if (format == GL_LUMINANCE_ALPHA) channels = 2;
+  const std::vector<uint8_t> bytes = webgl_bytes(xt_arg(argc, argv, 10));
+  const size_t count = (size_t)width * height * depth;
+  if (bytes.size() < count * (size_t)channels) {
+    context->set_error(GL_INVALID_VALUE);
+    return XT_UNDEFINED;
+  }
+  std::vector<uint8_t> rgba;
+  webgl_convert_pixels(bytes.data(), (int)count, format, false, &rgba);
+  context->tex_sub_image_3d(texture, x, y, z, width, height, depth, rgba.data());
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_framebuffer_texture_layer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  context->framebuffer_texture_layer(
+      context->bound_framebuffer_id(),
+      webgl_object_id(xt_arg(argc, argv, 2), "__xt_gl_texture"),
+      webgl_int(argc, argv, 1, GL_COLOR_ATTACHMENT0), webgl_int(argc, argv, 4, 0));
+  return XT_UNDEFINED;
+}
 
 METHOD(webgl2_get_transform_feedback_varying) {
   (void)env;
@@ -259,12 +312,6 @@ METHOD(webgl2_get_sync_parameter) {
 
 /* -- uniform blocks and indexed queries ---------------------------------- */
 
-METHOD(webgl2_get_indexed_parameter) {
-  (void)env;
-  (void)argc;
-  (void)argv;
-  return XT_NULL;
-}
 
 METHOD(webgl2_get_uniform_indices) {
   (void)env;
@@ -290,19 +337,7 @@ METHOD(webgl2_get_uniform_block_index) {
   return xt_number((double)index);
 }
 
-METHOD(webgl2_get_active_uniform_block_parameter) {
-  (void)env;
-  (void)argc;
-  (void)argv;
-  return xt_number(0);
-}
 
-METHOD(webgl2_get_active_uniform_block_name) {
-  (void)env;
-  (void)argc;
-  (void)argv;
-  return XT_NULL;
-}
 
 /* -- buffers ------------------------------------------------------------- */
 
@@ -340,22 +375,80 @@ METHOD(webgl2_get_buffer_sub_data) {
 
 /* -- textures ------------------------------------------------------------ */
 
+METHOD(webgl2_drawing_buffer_storage) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->drawing_buffer_storage(webgl_int(argc, argv, 0, 0),
+                                    webgl_int(argc, argv, 1, 0));
+  }
+  return XT_UNDEFINED;
+}
+
 METHOD(webgl2_tex_storage_2d) {
   (void)env;
   xtgui::WebGLContext *context = context_of(self);
   if (context != nullptr) {
     const uint32_t texture = context->bound_texture(0);
-    context->tex_storage_2d(texture, webgl_int(argc, argv, 1, 1),
-                            webgl_int(argc, argv, 3, 0), webgl_int(argc, argv, 4, 0));
+    const int internalformat = webgl_int(argc, argv, 2, 0x8058);  // GL_RGBA8
+    context->tex_storage_format(texture, webgl_int(argc, argv, 1, 1),
+                                webgl_int(argc, argv, 3, 0), webgl_int(argc, argv, 4, 0),
+                                xtgui::webgl_storage_format(internalformat));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_tex_storage_3d) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const int internalformat = webgl_int(argc, argv, 2, 0x8058);  // GL_RGBA8
+  context->tex_storage_3d(context->bound_texture(0), webgl_int(argc, argv, 1, 1),
+                          webgl_int(argc, argv, 3, 0), webgl_int(argc, argv, 4, 0),
+                          webgl_int(argc, argv, 5, 0),
+                          xtgui::webgl_storage_format(internalformat),
+                          webgl_int(argc, argv, 0, GL_TEXTURE_2D_ARRAY));
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_tex_image_3d) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const uint32_t texture = context->bound_texture(0);
+  if (texture == 0) return XT_UNDEFINED;
+  if (webgl_int(argc, argv, 1, 0) != 0) return XT_UNDEFINED;
+  const int internalformat = webgl_int(argc, argv, 2, GL_RGBA);
+  const int width = webgl_int(argc, argv, 3, 0);
+  const int height = webgl_int(argc, argv, 4, 0);
+  const int depth = webgl_int(argc, argv, 5, 0);
+  const int format = webgl_int(argc, argv, 7, GL_RGBA);
+  const int type = webgl_int(argc, argv, 8, GL_UNSIGNED_BYTE);
+  if (type != GL_UNSIGNED_BYTE || width <= 0 || height <= 0 || depth <= 0) {
+    context->set_error(GL_INVALID_VALUE);
+    return XT_UNDEFINED;
+  }
+  int channels = 1;
+  if (format == GL_RGBA) channels = 4;
+  else if (format == GL_RGB) channels = 3;
+  else if (format == GL_LUMINANCE_ALPHA) channels = 2;
+  const std::vector<uint8_t> bytes = webgl_bytes(xt_arg(argc, argv, 9));
+  const size_t count = (size_t)width * height * depth;
+  std::vector<uint8_t> rgba;
+  if (bytes.empty()) {
+    rgba.assign(count * 4, 0);
+  } else if (bytes.size() < count * (size_t)channels) {
+    context->set_error(GL_INVALID_VALUE);
+    return XT_UNDEFINED;
+  } else {
+    webgl_convert_pixels(bytes.data(), (int)count, format, false, &rgba);
   }
+  context->tex_image_3d(texture, width, height, depth,
+                        xtgui::webgl_storage_format(internalformat), rgba.data(),
+                        webgl_int(argc, argv, 0, GL_TEXTURE_2D_ARRAY));
   return XT_UNDEFINED;
 }
 
-WEBGL2_NOOP(webgl2_tex_storage_3d)
-WEBGL2_NOOP(webgl2_tex_image_3d)
-WEBGL2_NOOP(webgl2_tex_sub_image_3d)
-WEBGL2_NOOP(webgl2_compressed_tex_image2d)
-WEBGL2_NOOP(webgl2_compressed_tex_sub_image2d)
 WEBGL2_NOOP(webgl2_compressed_tex_image3d)
 WEBGL2_NOOP(webgl2_compressed_tex_sub_image3d)
 
@@ -410,8 +503,30 @@ METHOD(webgl2_clear_buffer_fi) {
 
 METHOD(webgl2_draw_buffers) {
   (void)env;
-  (void)argc;
-  (void)argv;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const xt_value list = xt_arg(argc, argv, 0);
+  std::vector<double> values = webgl_numbers(list);
+  if (values.empty()) {
+    /* `webgl_numbers` only walks typed arrays; plain WebGL argument arrays
+     * (`drawBuffers([gl.COLOR_ATTACHMENT0, ...])`) need the element accessor. */
+    const double length = xt_to_number(xt_get(list, xt_string_from_cstr("length")));
+    if (length > 0.0 && length <= 16.0) {
+      for (int i = 0; i < (int)length; i++) {
+        values.push_back(xt_to_number(xt_get(list, xt_number((double)i))));
+      }
+    }
+  }
+  std::vector<int> buffers(values.size());
+  for (size_t i = 0; i < values.size(); i++) buffers[i] = (int)values[i];
+  context->draw_buffers((int)buffers.size(), buffers.data());
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_read_buffer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) context->read_buffer(webgl_int(argc, argv, 0, GL_BACK));
   return XT_UNDEFINED;
 }
 

package/runtime/ext_gui/dom_api_webgl2_draw.cpp

@@ -18,7 +18,7 @@
 namespace domapi {
 namespace {
 
-xtgui::WebGLContext *context_of(xt_value self) { return webgl_from_context(self); }
+xtgui::WebGLContext *context_of(xt_value self) { return webgl_live_context(self); }
 
 uint32_t vertex_array_argument(xt_value value) {
   return webgl_object_id(value, "__xt_gl_vertex_array");
@@ -81,7 +81,7 @@ METHOD(webgl2_vertex_attrib_ipointer) {
 namespace {
 
 void attrib_integer(xt_value self, int32_t argc, xt_value *argv, bool is_unsigned) {
-  xtgui::WebGLContext *context = webgl_from_context(self);
+  xtgui::WebGLContext *context = webgl_live_context(self);
   if (context == nullptr) return;
   float values[4] = {0.0f, 0.0f, 0.0f, 1.0f};
   const std::vector<double> numbers = webgl_numbers(xt_arg(argc, argv, 1));
@@ -162,7 +162,7 @@ METHOD(webgl2_draw_range_elements) {
 namespace {
 
 void uniform_unsigned(xt_value self, int32_t argc, xt_value *argv, int components, bool vector) {
-  xtgui::WebGLContext *context = webgl_from_context(self);
+  xtgui::WebGLContext *context = webgl_live_context(self);
   if (context == nullptr) return;
   xt_value handle = xt_arg(argc, argv, 0);
   if (!XT_IS_OBJECT(handle)) return;

package/runtime/ext_gui/dom_api_webgl_buffer.cpp

@@ -14,7 +14,7 @@
 namespace domapi {
 namespace {
 
-xtgui::WebGLContext *context_of(xt_value self) { return webgl_from_context(self); }
+xtgui::WebGLContext *context_of(xt_value self) { return webgl_live_context(self); }
 
 uint32_t buffer_argument(xt_value value) { return webgl_object_id(value, "__xt_gl_buffer"); }
 
@@ -85,6 +85,10 @@ METHOD(webgl_get_buffer_parameter) {
   const int pname = webgl_int(argc, argv, 1, 0);
   const uint32_t buffer = context->bound_buffer(target);
   if (pname == GL_BUFFER_SIZE) return xt_number((double)context->buffer_size(buffer));
+  if (pname == 0x8765) {  // GL_BUFFER_USAGE
+    xtgui::WebGLBuffer *record = context->buffer(buffer);
+    return xt_number(record != nullptr ? (double)record->usage : 0.0);
+  }
   return xt_number(0);
 }
 
@@ -116,7 +120,7 @@ METHOD(webgl_vertex_attrib_pointer) {
 namespace {
 
 void attrib_value(xt_value self, int32_t argc, xt_value *argv, int components) {
-  xtgui::WebGLContext *context = webgl_from_context(self);
+  xtgui::WebGLContext *context = webgl_live_context(self);
   if (context == nullptr) return;
   float values[4] = {0.0f, 0.0f, 0.0f, 1.0f};
   for (int i = 0; i < components; i++) values[i] = (float)webgl_number(argc, argv, i + 1, 0.0);