xbintsc 0.5.37 → 0.5.41

package/runtime/ext_gui/dom_api_canvas_state.cpp

@@ -0,0 +1,217 @@
+/*
+ * xbintsc GUI engine — the Canvas2D state additions.
+ *
+ * `globalCompositeOperation`, the four shadow properties, the image-smoothing
+ * flags, and the path/clip hit-testing entry points. They live apart from the
+ * original style bindings so both translation units stay small.
+ */
+
+#include "dom_api_internal.h"
+
+#include <string>
+#include <vector>
+
+#include "canvas.h"
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+namespace domapi {
+
+namespace {
+
+/** Parse a trailing fill-rule argument (`"evenodd"`/`"nonzero"`). */
+bool fill_rule_arg(xt_value value, bool *even_odd) {
+  if (!XT_IS_STRING(value)) return false;
+  const std::string rule = to_string_value(value);
+  if (rule == "evenodd") {
+    *even_odd = true;
+    return true;
+  }
+  if (rule == "nonzero") {
+    *even_odd = false;
+    return true;
+  }
+  return false;
+}
+
+}  // namespace
+
+METHOD(canvas_global_composite_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_string_from_cstr(canvas != nullptr ? canvas->global_composite_operation().c_str()
+                                               : "source-over");
+}
+
+METHOD(canvas_global_composite_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_global_composite_operation(canvas_string_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_shadow_color_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_string_from_cstr(canvas != nullptr ? canvas->shadow_color().c_str()
+                                               : "rgba(0, 0, 0, 0)");
+}
+
+METHOD(canvas_shadow_color_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_shadow_color(canvas_string_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_shadow_blur_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_number(canvas != nullptr ? canvas->shadow_blur() : 0.0);
+}
+
+METHOD(canvas_shadow_blur_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_shadow_blur((float)canvas_number_arg(argc, argv, 0, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_shadow_offset_x_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_number(canvas != nullptr ? canvas->shadow_offset_x() : 0.0);
+}
+
+METHOD(canvas_shadow_offset_x_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_shadow_offset_x((float)canvas_number_arg(argc, argv, 0, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_shadow_offset_y_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_number(canvas != nullptr ? canvas->shadow_offset_y() : 0.0);
+}
+
+METHOD(canvas_shadow_offset_y_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_shadow_offset_y((float)canvas_number_arg(argc, argv, 0, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_image_smoothing_enabled_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_bool(canvas == nullptr || canvas->image_smoothing_enabled());
+}
+
+METHOD(canvas_image_smoothing_enabled_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) {
+    canvas->set_image_smoothing_enabled(value_truthy(xt_arg(argc, argv, 0)));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_image_smoothing_quality_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  return xt_string_from_cstr(canvas != nullptr ? canvas->image_smoothing_quality().c_str()
+                                               : "low");
+}
+
+METHOD(canvas_image_smoothing_quality_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->set_image_smoothing_quality(canvas_string_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_clip) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr) return XT_UNDEFINED;
+  bool even_odd = false;
+  bool has_path = false;
+  std::vector<xtgui::CanvasSubpath> path;
+  for (int32_t i = 0; i < argc; i++) {
+    xt_value value = xt_arg(argc, argv, i);
+    bool rule = false;
+    if (fill_rule_arg(value, &rule)) {
+      even_odd = rule;
+    } else if (path2d_is(value)) {
+      path = path2d_subpaths(value);
+      has_path = true;
+    }
+  }
+  if (has_path) {
+    canvas->clip_paths(path, even_odd);
+  } else {
+    canvas->clip(even_odd);
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_is_point_in_path) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr || argc == 0) return XT_FALSE;
+  int32_t index = 0;
+  std::vector<xtgui::CanvasSubpath> path;
+  bool has_path = false;
+  if (path2d_is(xt_arg(argc, argv, 0))) {
+    path = path2d_subpaths(xt_arg(argc, argv, 0));
+    has_path = true;
+    index = 1;
+  }
+  const float x = (float)canvas_number_arg(argc, argv, index, 0.0);
+  const float y = (float)canvas_number_arg(argc, argv, index + 1, 0.0);
+  bool even_odd = false;
+  for (int32_t i = index + 2; i < argc; i++) fill_rule_arg(xt_arg(argc, argv, i), &even_odd);
+  const bool inside =
+      has_path ? canvas->is_point_in_paths(path, x, y, even_odd)
+               : canvas->is_point_in_path(x, y, even_odd);
+  return xt_bool(inside);
+}
+
+METHOD(canvas_is_point_in_stroke) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr || argc == 0) return XT_FALSE;
+  int32_t index = 0;
+  std::vector<xtgui::CanvasSubpath> path;
+  bool has_path = false;
+  if (path2d_is(xt_arg(argc, argv, 0))) {
+    path = path2d_subpaths(xt_arg(argc, argv, 0));
+    has_path = true;
+    index = 1;
+  }
+  const float x = (float)canvas_number_arg(argc, argv, index, 0.0);
+  const float y = (float)canvas_number_arg(argc, argv, index + 1, 0.0);
+  const bool inside =
+      has_path ? canvas->is_point_in_stroke_paths(path, x, y) : canvas->is_point_in_stroke(x, y);
+  return xt_bool(inside);
+}
+
+}  // namespace domapi
+
+#undef METHOD

package/runtime/ext_gui/dom_api_internal.h

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "gui_engine.h"
+#include "dom_api_webgl_internal.h"
 
 namespace domapi {
 
@@ -52,6 +53,23 @@ xt_value class_list_proto();
 xt_value style_proto();
 xt_value computed_style_proto();
 xt_value canvas_proto();
+/** The `getContextAttributes()` object for a freshly created 2D context. */
+xt_value canvas_context_attributes(xt_value requested, bool alpha);
+/** `OffscreenCanvas.prototype`. */
+xt_value offscreen_canvas_proto();
+/** `new OffscreenCanvas(width, height)`. */
+xt_value offscreen_canvas_create(int32_t argc, xt_value *argv);
+/** `canvas.transferControlToOffscreen()`. */
+xt_value canvas_transfer_control_to_offscreen(xt_value self, xt_value env, int32_t argc,
+                                              xt_value *argv);
+xt_value offscreen_get_context(xt_value self, xt_value env, int32_t argc, xt_value *argv);
+xt_value offscreen_width_get(xt_value self, xt_value env, int32_t argc, xt_value *argv);
+xt_value offscreen_width_set(xt_value self, xt_value env, int32_t argc, xt_value *argv);
+xt_value offscreen_height_get(xt_value self, xt_value env, int32_t argc, xt_value *argv);
+xt_value offscreen_height_set(xt_value self, xt_value env, int32_t argc, xt_value *argv);
+xt_value offscreen_transfer_to_image_bitmap(xt_value self, xt_value env, int32_t argc,
+                                            xt_value *argv);
+xt_value offscreen_convert_to_blob(xt_value self, xt_value env, int32_t argc, xt_value *argv);
 xt_value canvas_gradient_proto();
 xt_value webgl_proto();
 xt_value webgl2_proto();
@@ -91,43 +109,7 @@ xt_value canvas_gradient_handle(xt_value context, const xtgui::Canvas2D *canvas,
 uint64_t canvas_gradient_id(xt_value handle, const xtgui::Canvas2D *canvas);
 
 /* -- WebGL helpers shared by `dom_api_webgl*.cpp` ------------------------- */
-
-/** The engine WebGL context behind a context handle, or null. */
-xtgui::WebGLContext *webgl_from_context(xt_value self);
-/** Like `webgl_from_context`, but null while the context is lost: every GL
- * entry point except `getError`/`isContextLost` is a no-op in that state. */
-xtgui::WebGLContext *webgl_live_context(xt_value self);
-/** The numeric context id stored on a context handle (0 when absent). */
-uint64_t webgl_context_id(xt_value self);
-/** Create the JavaScript handle for a canvas's WebGL context. */
-xt_value webgl_context_handle(xt_value element, xtgui::WebGLContext *context);
-/** The id stored on an object handle under `key`, or 0. */
-uint32_t webgl_object_id(xt_value handle, const char *key);
-/** Build an object handle (`{__xt_gl_context, __xt_gl_<key>}`). */
-xt_value webgl_make_object(xt_value context, const char *key, uint32_t id,
-                           const std::string &kind);
-double webgl_number(int32_t argc, xt_value *argv, int32_t index, double fallback);
-int webgl_int(int32_t argc, xt_value *argv, int32_t index, int fallback);
-std::string webgl_string(int32_t argc, xt_value *argv, int32_t index);
-/** Read an array/typed array of numbers. */
-std::vector<double> webgl_numbers(xt_value value);
-/** Read the raw bytes of a typed array / ArrayBuffer (or a byte array). */
-std::vector<uint8_t> webgl_bytes(xt_value value);
-/** Store `count` bytes into a typed array / array handle. */
-void webgl_write_bytes(xt_value target, const uint8_t *bytes, size_t count);
-/** Convert a source pixel array (RGBA/RGB/LUMINANCE/…) to RGBA8. */
-void webgl_convert_pixels(const uint8_t *source, int count, int format, bool premultiply,
-                          std::vector<uint8_t> *out);
-/** Decode a `texImage2D` source (`<img>`, `<canvas>`, `<video>`, `ImageData`,
- * `ImageBitmap`) into top-down RGBA8. */
-bool webgl_read_source(xt_value source, int *width, int *height,
-                       std::vector<uint8_t> *rgba, bool premultiply);
-/** Read the `UNPACK_FLIP_Y_WEBGL` / `UNPACK_PREMULTIPLY_ALPHA_WEBGL` flags set
- * through `pixelStorei`. */
-void webgl_unpack_flags(xt_value context, bool *flip_y, bool *premultiply);
-/** Extension object for a compressed-texture family (null when unsupported,
- * undefined when the name is not one of those extensions). */
-xt_value webgl_compressed_extension(const std::string &name, xtgui::WebGLContext *context);
+/* Declared in `dom_api_webgl_internal.h`, included above. */
 
 /** How a pending handle names the node it will bind to. */
 enum PendingKind { pending_by_id = 1, pending_by_selector = 2 };
@@ -285,6 +267,23 @@ METHOD(canvas_line_width_get);
 METHOD(canvas_line_width_set);
 METHOD(canvas_global_alpha_get);
 METHOD(canvas_global_alpha_set);
+METHOD(canvas_global_composite_get);
+METHOD(canvas_global_composite_set);
+METHOD(canvas_shadow_color_get);
+METHOD(canvas_shadow_color_set);
+METHOD(canvas_shadow_blur_get);
+METHOD(canvas_shadow_blur_set);
+METHOD(canvas_shadow_offset_x_get);
+METHOD(canvas_shadow_offset_x_set);
+METHOD(canvas_shadow_offset_y_get);
+METHOD(canvas_shadow_offset_y_set);
+METHOD(canvas_image_smoothing_enabled_get);
+METHOD(canvas_image_smoothing_enabled_set);
+METHOD(canvas_image_smoothing_quality_get);
+METHOD(canvas_image_smoothing_quality_set);
+METHOD(canvas_clip);
+METHOD(canvas_is_point_in_path);
+METHOD(canvas_is_point_in_stroke);
 METHOD(canvas_font_get);
 METHOD(canvas_font_set);
 METHOD(canvas_text_align_get);

package/runtime/ext_gui/dom_api_offscreen.cpp

@@ -0,0 +1,213 @@
+/*
+ * xbintsc GUI engine — `OffscreenCanvas`.
+ *
+ * An offscreen canvas is a `Canvas2D` bitmap with no DOM element behind it. It
+ * is created either by `new OffscreenCanvas(w, h)` or by transferring a live
+ * `<canvas>` element (`transferControlToOffscreen`), in which case the element
+ * keeps its bitmap and only the context ownership moves.
+ *
+ * Ownership stays with the window (`offscreen_canvases`), like every other
+ * canvas; the process-wide id table makes the bitmap reachable from
+ * `drawImage`/`createPattern`/`texImage2D` without a DOM node.
+ */
+
+#include "dom_api_internal.h"
+
+#include <string>
+#include <vector>
+
+#include "canvas.h"
+#include "gui_engine.h"
+#include "image_bitmap.h"
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+namespace domapi {
+
+namespace {
+
+xtgui::Canvas2D *offscreen_canvas(xt_value self) {
+  xt_value id = xt_object_get_cstr(self, "__xt_gui_canvas");
+  if (!XT_IS_NUMBER(id)) return nullptr;
+  return xtgui::xt_canvas_by_id((uint64_t)xt_to_number(id));
+}
+
+xt_value make_offscreen(xtgui::Canvas2D *canvas, xt_value window) {
+  xt_value handle = xt_object_new_with_proto(offscreen_canvas_proto());
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_canvas"), xt_number((double)canvas->id()));
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_window"), window);
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_offscreen"), XT_TRUE);
+  /* `ctx.canvas` of an offscreen context returns the offscreen object. */
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_node"), handle);
+  return handle;
+}
+
+xt_value image_bitmap_handle(const xtgui::Image &image) {
+  const uint64_t id = xtgui::xt_image_bitmap_add(image);
+  xt_value name = xt_string_from_cstr("ImageBitmap");
+  xt_value constructor = xt_browser_type(1, &name);
+  xt_value prototype = xt_object_get_cstr(constructor, "prototype");
+  xt_value bitmap = XT_IS_OBJECT(prototype) ? xt_object_new_with_proto(prototype)
+                                            : xt_object_new();
+  xt_object_set(bitmap, xt_string_from_cstr("width"), xt_number(image.width));
+  xt_object_set(bitmap, xt_string_from_cstr("height"), xt_number(image.height));
+  xt_object_set(bitmap, xt_string_from_cstr("__xt_bitmap"), xt_number((double)id));
+  return bitmap;
+}
+
+}  // namespace
+
+xt_value offscreen_canvas_proto() {
+  static xt_value proto = XT_UNDEFINED;
+  if (XT_IS_OBJECT(proto)) return proto;
+  proto = xt_object_new();
+  xt_gc_add_root(&proto);
+  struct Entry {
+    const char *name;
+    void *getter;
+    void *setter;
+  };
+  const Entry properties[] = {
+      {"width", (void *)offscreen_width_get, (void *)offscreen_width_set},
+      {"height", (void *)offscreen_height_get, (void *)offscreen_height_set},
+  };
+  for (const Entry &property : properties) {
+    xt_object_define_getter(proto, xt_string_from_cstr(property.name),
+                            xt_closure_new(property.getter, 0, nullptr));
+    xt_object_define_setter(proto, xt_string_from_cstr(property.name),
+                            xt_closure_new(property.setter, 0, nullptr));
+  }
+  struct Method {
+    const char *name;
+    void *fn;
+  };
+  const Method methods[] = {
+      {"getContext", (void *)offscreen_get_context},
+      {"transferToImageBitmap", (void *)offscreen_transfer_to_image_bitmap},
+      {"convertToBlob", (void *)offscreen_convert_to_blob},
+  };
+  for (const Method &method : methods) {
+    xt_object_set(proto, xt_string_from_cstr(method.name),
+                  xt_closure_new(method.fn, 0, nullptr));
+  }
+  return proto;
+}
+
+xt_value offscreen_canvas_create(int32_t argc, xt_value *argv) {
+  xt_value window = xt_gui_ensure_window();
+  XtGuiWindow *win = xt_gui_window_from_this(window);
+  if (win == nullptr) return XT_NULL;
+  int width = argc >= 1 ? (int)xt_to_number(xt_arg(argc, argv, 0)) : 300;
+  int height = argc >= 2 ? (int)xt_to_number(xt_arg(argc, argv, 1)) : 150;
+  if (width < 1) width = 1;
+  if (height < 1) height = 1;
+  auto canvas = std::make_unique<xtgui::Canvas2D>(width, height);
+  xtgui::Canvas2D *raw = canvas.get();
+  win->offscreen_canvases[raw->id()] = std::move(canvas);
+  return make_offscreen(raw, window);
+}
+
+METHOD(offscreen_width_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = offscreen_canvas(self);
+  return xt_number(canvas != nullptr ? canvas->width() : 0);
+}
+
+METHOD(offscreen_width_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = offscreen_canvas(self);
+  if (canvas != nullptr) canvas->resize((int)canvas_number_arg(argc, argv, 0, 0.0), canvas->height());
+  return XT_UNDEFINED;
+}
+
+METHOD(offscreen_height_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = offscreen_canvas(self);
+  return xt_number(canvas != nullptr ? canvas->height() : 0);
+}
+
+METHOD(offscreen_height_set) {
+  (void)env;
+  xtgui::Canvas2D *canvas = offscreen_canvas(self);
+  if (canvas != nullptr) canvas->resize(canvas->width(), (int)canvas_number_arg(argc, argv, 0, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(offscreen_get_context) {
+  (void)env;
+  xtgui::Canvas2D *canvas = offscreen_canvas(self);
+  if (canvas == nullptr) return XT_NULL;
+  const std::string mode = canvas_string_arg(argc, argv, 0);
+  /* The GPU context needs a DOM node for its texture table; the 2D bitmap does
+   * not, so only "2d" resolves here. */
+  if (mode != "2d") return XT_NULL;
+  xt_value cached = xt_object_get_cstr(self, "__xt_gui_ctx");
+  if (XT_IS_OBJECT(cached)) return cached;
+  xt_value attributes = xt_arg(argc, argv, 1);
+  bool alpha = true;
+  if (XT_IS_OBJECT(attributes)) {
+    xt_value value = xt_object_get_cstr(attributes, "alpha");
+    if (XT_IS_BOOL(value)) alpha = value_truthy(value);
+  }
+  canvas->set_alpha(alpha);
+  xt_value context = xt_object_new_with_proto(canvas_proto());
+  xt_object_set(context, xt_string_from_cstr("__xt_gui_canvas"), xt_number((double)canvas->id()));
+  xt_object_set(context, xt_string_from_cstr("__xt_gui_node"), self);
+  xt_object_set(context, xt_string_from_cstr("__xt_gui_ctx_attributes"),
+                canvas_context_attributes(attributes, alpha));
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_ctx"), context);
+  return context;
+}
+
+METHOD(offscreen_transfer_to_image_bitmap) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = offscreen_canvas(self);
+  if (canvas == nullptr || canvas->image().width <= 0) return XT_NULL;
+  return image_bitmap_handle(canvas->image());
+}
+
+METHOD(offscreen_convert_to_blob) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = offscreen_canvas(self);
+  if (canvas == nullptr) return xt_promise_reject(xt_string_from_cstr("InvalidStateError"));
+  std::vector<unsigned char> png;
+  if (!canvas->encode_png(&png)) return xt_promise_reject(xt_string_from_cstr("InvalidStateError"));
+  xt_value data = xt_array_new(0, nullptr);
+  for (unsigned char byte : png) xt_array_push(data, xt_number((double)byte));
+  xt_value blob = xt_object_new();
+  xt_object_set(blob, xt_string_from_cstr("type"), xt_string_from_cstr("image/png"));
+  xt_object_set(blob, xt_string_from_cstr("size"), xt_number((double)png.size()));
+  xt_object_set(blob, xt_string_from_cstr("__xt_gui_blob_data"), data);
+  return xt_promise_resolve(blob);
+}
+
+METHOD(canvas_transfer_control_to_offscreen) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value existing = xt_object_get_cstr(self, "__xt_gui_offscreen");
+  if (XT_IS_OBJECT(existing)) return existing;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (win == nullptr || node == nullptr || !node->isElement() || !node->isTag("canvas")) {
+    return XT_NULL;
+  }
+  if (xt_gui_webgl_find(win, node) != nullptr) return XT_NULL;
+  xtgui::Canvas2D *canvas = xt_gui_canvas_get(win, node);
+  if (canvas == nullptr) return XT_NULL;
+  xt_value handle = make_offscreen(canvas, win->object);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_offscreen"), handle);
+  return handle;
+}
+
+}  // namespace domapi
+
+#undef METHOD

package/runtime/ext_gui/dom_api_proto.cpp

@@ -111,6 +111,7 @@ xt_value node_proto() {
   define_method(proto, "pause", (void *)node_pause);
   define_method(proto, "load", (void *)node_load);
   define_method(proto, "getContext", (void *)node_get_context);
+  define_method(proto, "transferControlToOffscreen", (void *)canvas_transfer_control_to_offscreen);
   /* `toDataURL`/`toBlob` belong to the canvas *element*, as in the DOM. */
   define_method(proto, "toDataURL", (void *)canvas_to_data_url);
   define_method(proto, "toBlob", (void *)canvas_to_blob);
@@ -210,6 +211,20 @@ xt_value canvas_proto() {
   define_setter(proto, "lineWidth", (void *)canvas_line_width_set);
   define_getter(proto, "globalAlpha", (void *)canvas_global_alpha_get);
   define_setter(proto, "globalAlpha", (void *)canvas_global_alpha_set);
+  define_getter(proto, "globalCompositeOperation", (void *)canvas_global_composite_get);
+  define_setter(proto, "globalCompositeOperation", (void *)canvas_global_composite_set);
+  define_getter(proto, "shadowColor", (void *)canvas_shadow_color_get);
+  define_setter(proto, "shadowColor", (void *)canvas_shadow_color_set);
+  define_getter(proto, "shadowBlur", (void *)canvas_shadow_blur_get);
+  define_setter(proto, "shadowBlur", (void *)canvas_shadow_blur_set);
+  define_getter(proto, "shadowOffsetX", (void *)canvas_shadow_offset_x_get);
+  define_setter(proto, "shadowOffsetX", (void *)canvas_shadow_offset_x_set);
+  define_getter(proto, "shadowOffsetY", (void *)canvas_shadow_offset_y_get);
+  define_setter(proto, "shadowOffsetY", (void *)canvas_shadow_offset_y_set);
+  define_getter(proto, "imageSmoothingEnabled", (void *)canvas_image_smoothing_enabled_get);
+  define_setter(proto, "imageSmoothingEnabled", (void *)canvas_image_smoothing_enabled_set);
+  define_getter(proto, "imageSmoothingQuality", (void *)canvas_image_smoothing_quality_get);
+  define_setter(proto, "imageSmoothingQuality", (void *)canvas_image_smoothing_quality_set);
   define_getter(proto, "font", (void *)canvas_font_get);
   define_setter(proto, "font", (void *)canvas_font_set);
   define_getter(proto, "textAlign", (void *)canvas_text_align_get);
@@ -245,6 +260,9 @@ xt_value canvas_proto() {
   define_method(proto, "bezierCurveTo", (void *)canvas_bezier_curve_to);
   define_method(proto, "fill", (void *)canvas_fill);
   define_method(proto, "stroke", (void *)canvas_stroke);
+  define_method(proto, "clip", (void *)canvas_clip);
+  define_method(proto, "isPointInPath", (void *)canvas_is_point_in_path);
+  define_method(proto, "isPointInStroke", (void *)canvas_is_point_in_stroke);
   define_method(proto, "clearRect", (void *)canvas_clear_rect);
   define_method(proto, "fillRect", (void *)canvas_fill_rect);
   define_method(proto, "strokeRect", (void *)canvas_stroke_rect);

package/runtime/ext_gui/dom_api_webgl.cpp

@@ -223,6 +223,16 @@ xt_value webgl_proto() {
   define_getter(proto, "canvas", (void *)webgl_canvas_get);
   define_getter(proto, "drawingBufferWidth", (void *)webgl_drawing_buffer_width_get);
   define_getter(proto, "drawingBufferHeight", (void *)webgl_drawing_buffer_height_get);
+  /* `gl.constructor.name` is how three.js tells a WebGL 2 context from a
+   * WebGL 1 one. A host-type value from `xt_browser_type` later replaces this
+   * with the real constructor (and its `prototype`), but the context must
+   * answer the name even when the page never read the global. */
+  {
+    xt_value constructor = xt_object_new();
+    xt_object_set(constructor, xt_string_from_cstr("name"),
+                  xt_string_from_cstr("WebGLRenderingContext"));
+    xt_object_set(proto, xt_string_from_cstr("constructor"), constructor);
+  }
   g_webgl_proto = proto;
   return proto;
 }
@@ -321,15 +331,17 @@ std::vector<uint8_t> webgl_bytes(xt_value value) {
     const double length = xt_to_number(xt_get(value, xt_string_from_cstr("byteLength")));
     if (!(length > 0.0) || !xt_is_array_buffer(buffer)) return out;
     out.resize((size_t)length);
-    for (uint32_t i = 0; i < (uint32_t)length; i++) {
-      out[i] = xt_array_buffer_get_byte(buffer, offset + i);
-    }
+    /* The runtime stores an ArrayBuffer as one byte value per array slot, so
+     * this is still an element loop — but one call into the runtime instead of
+     * one extern call per byte, which is what a multi-megabyte vertex buffer or
+     * `texImage2D` pays for. */
+    out.resize(xt_array_buffer_copy_bytes_out(buffer, offset, out.data(), (uint32_t)length));
     return out;
   }
   if (xt_is_array_buffer(value)) {
     const uint32_t length = xt_array_buffer_byte_length(value);
     out.resize(length);
-    for (uint32_t i = 0; i < length; i++) out[i] = xt_array_buffer_get_byte(value, i);
+    out.resize(xt_array_buffer_copy_bytes_out(value, 0, out.data(), length));
     return out;
   }
   const std::vector<double> numbers = webgl_numbers(value);
@@ -346,13 +358,21 @@ std::vector<uint8_t> webgl_bytes(xt_value value) {
 void webgl_write_bytes(xt_value target, const uint8_t *bytes, size_t count) {
   if (!XT_IS_OBJECT(target) || bytes == nullptr) return;
   const int kind = xt_typed_array_kind_of(target);
-  for (size_t i = 0; i < count; i++) {
-    if (kind >= 0) {
-      xt_typed_array_write(target, (uint32_t)i, xt_number((double)bytes[i]));
-    } else {
-      xt_set(target, xt_number((double)i), xt_number((double)bytes[i]));
+  if (kind >= 0) {
+    xt_value buffer = xt_typed_array_buffer_of(target);
+    const uint32_t offset = xt_typed_array_byte_offset_of(target);
+    if (xt_is_array_buffer(buffer)) {
+      xt_array_buffer_copy_bytes_in(buffer, offset, bytes, (uint32_t)count);
+      return;
     }
   }
+  if (xt_is_array_buffer(target)) {
+    xt_array_buffer_copy_bytes_in(target, 0, bytes, (uint32_t)count);
+    return;
+  }
+  for (size_t i = 0; i < count; i++) {
+    xt_set(target, xt_number((double)i), xt_number((double)bytes[i]));
+  }
 }
 
 /* -- context handle members ---------------------------------------------- */

package/runtime/ext_gui/dom_api_webgl2.cpp

@@ -121,12 +121,44 @@ xt_value uint_array(const unsigned int *values, int count) {
 xt_value webgl2_proto() {
   xt_gc_add_root(&g_webgl2_proto);
   if (XT_IS_OBJECT(g_webgl2_proto)) return g_webgl2_proto;
-  xt_value proto = xt_object_new_with_proto(webgl_proto());
+  /* WebGL 2 shares the WebGL 1 surface but not its prototype: in a browser
+   * `gl2 instanceof WebGLRenderingContext` is false, which is how three.js and
+   * other libraries detect WebGL 2. Copy the WebGL 1 members instead of
+   * inheriting the WebGL 1 prototype. */
+  xt_value webgl1 = webgl_proto();
+  xt_value proto = xt_object_new();
+  xt_value keys = xt_object_keys(webgl1);
+  const double count = xt_to_number(xt_array_length(keys));
+  for (int32_t i = 0; i < (int32_t)count; i++) {
+    xt_value key = xt_array_get(keys, xt_number((double)i));
+    const char *name = xt_string_data(key);
+    if (name == nullptr) continue;
+    /* `constructor` gets the WebGL 2 name below. The three host getters are
+     * accessors, not values: reading them here would run them against the
+     * WebGL 1 prototype and copy `undefined`. Reinstall them as accessors. */
+    if (strcmp(name, "constructor") == 0 || strcmp(name, "canvas") == 0 ||
+        strcmp(name, "drawingBufferWidth") == 0 || strcmp(name, "drawingBufferHeight") == 0) {
+      continue;
+    }
+    xt_object_set(proto, key, xt_object_get(webgl1, key));
+  }
+  xt_object_define_getter(proto, xt_string_from_cstr("canvas"),
+                          xt_closure_new((void *)webgl_canvas_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("drawingBufferWidth"),
+                          xt_closure_new((void *)webgl_drawing_buffer_width_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("drawingBufferHeight"),
+                          xt_closure_new((void *)webgl_drawing_buffer_height_get, 0, nullptr));
 #define XT_WEBGL2_CONSTANT(name, value) \
   xt_object_set(proto, xt_string_from_cstr(#name), xt_number((double)(value)));
   XT_WEBGL2_CONSTANTS(XT_WEBGL2_CONSTANT)
 #undef XT_WEBGL2_CONSTANT
   for (const MethodEntry &method : kMethods) define_method(proto, method.name, method.fn);
+  {
+    xt_value constructor = xt_object_new();
+    xt_object_set(constructor, xt_string_from_cstr("name"),
+                  xt_string_from_cstr("WebGL2RenderingContext"));
+    xt_object_set(proto, xt_string_from_cstr("constructor"), constructor);
+  }
   g_webgl2_proto = proto;
   return proto;
 }