xbintsc 0.5.23 → 0.5.32

package/runtime/ext_gui/dom_api_webgl2.cpp

@@ -0,0 +1,434 @@
+/*
+ * xbintsc GUI engine — the WebGL 2 context prototype and its less-used API.
+ *
+ * The prototype inherits the WebGL 1 one, so every WebGL 1 method and constant
+ * is available on a WebGL 2 context. This unit adds the WebGL 2 constants and
+ * the parts of the API whose backend is either a no-op (queries, fences,
+ * transform feedback, uniform blocks) or a simple clear/copy (clearBuffer*,
+ * copyBufferSubData, getBufferSubData, texStorage2D).
+ */
+
+#include "dom_api_internal.h"
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "webgl.h"
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+namespace domapi {
+namespace {
+
+struct MethodEntry {
+  const char *name;
+  void *fn;
+};
+
+const MethodEntry kMethods[] = {
+    {"createVertexArray", (void *)webgl2_create_vertex_array},
+    {"deleteVertexArray", (void *)webgl2_delete_vertex_array},
+    {"bindVertexArray", (void *)webgl2_bind_vertex_array},
+    {"isVertexArray", (void *)webgl2_is_vertex_array},
+    {"vertexAttribIPointer", (void *)webgl2_vertex_attrib_ipointer},
+    {"vertexAttribI4i", (void *)webgl2_vertex_attrib_i4i},
+    {"vertexAttribI4iv", (void *)webgl2_vertex_attrib_i4iv},
+    {"vertexAttribI4ui", (void *)webgl2_vertex_attrib_i4ui},
+    {"vertexAttribI4uiv", (void *)webgl2_vertex_attrib_i4uiv},
+    {"vertexAttribDivisor", (void *)webgl2_vertex_attrib_divisor},
+    {"drawArraysInstanced", (void *)webgl2_draw_arrays_instanced},
+    {"drawElementsInstanced", (void *)webgl2_draw_elements_instanced},
+    {"drawRangeElements", (void *)webgl2_draw_range_elements},
+    {"uniform1ui", (void *)webgl2_uniform1ui},
+    {"uniform2ui", (void *)webgl2_uniform2ui},
+    {"uniform3ui", (void *)webgl2_uniform3ui},
+    {"uniform4ui", (void *)webgl2_uniform4ui},
+    {"createSampler", (void *)webgl2_create_sampler},
+    {"deleteSampler", (void *)webgl2_delete_sampler},
+    {"bindSampler", (void *)webgl2_bind_sampler},
+    {"samplerParameteri", (void *)webgl2_sampler_parameteri},
+    {"samplerParameterf", (void *)webgl2_sampler_parameterf},
+    {"getSamplerParameter", (void *)webgl2_get_sampler_parameter},
+    {"createQuery", (void *)webgl2_create_query},
+    {"deleteQuery", (void *)webgl2_delete_query},
+    {"beginQuery", (void *)webgl2_begin_query},
+    {"endQuery", (void *)webgl2_end_query},
+    {"getQuery", (void *)webgl2_get_query},
+    {"getQueryParameter", (void *)webgl2_get_query_parameter},
+    {"createTransformFeedback", (void *)webgl2_create_transform_feedback},
+    {"deleteTransformFeedback", (void *)webgl2_delete_transform_feedback},
+    {"bindTransformFeedback", (void *)webgl2_bind_transform_feedback},
+    {"beginTransformFeedback", (void *)webgl2_begin_transform_feedback},
+    {"endTransformFeedback", (void *)webgl2_end_transform_feedback},
+    {"pauseTransformFeedback", (void *)webgl2_pause_transform_feedback},
+    {"resumeTransformFeedback", (void *)webgl2_resume_transform_feedback},
+    {"transformFeedbackVaryings", (void *)webgl2_transform_feedback_varyings},
+    {"getTransformFeedbackVarying", (void *)webgl2_get_transform_feedback_varying},
+    {"fenceSync", (void *)webgl2_fence_sync},
+    {"deleteSync", (void *)webgl2_delete_sync},
+    {"clientWaitSync", (void *)webgl2_client_wait_sync},
+    {"waitSync", (void *)webgl2_wait_sync},
+    {"getSyncParameter", (void *)webgl2_get_sync_parameter},
+    {"bindBufferBase", (void *)webgl2_bind_buffer_base},
+    {"bindBufferRange", (void *)webgl2_bind_buffer_range},
+    {"getIndexedParameter", (void *)webgl2_get_indexed_parameter},
+    {"copyBufferSubData", (void *)webgl2_copy_buffer_sub_data},
+    {"getBufferSubData", (void *)webgl2_get_buffer_sub_data},
+    {"getUniformIndices", (void *)webgl2_get_uniform_indices},
+    {"getActiveUniforms", (void *)webgl2_get_active_uniforms},
+    {"getUniformBlockIndex", (void *)webgl2_get_uniform_block_index},
+    {"getActiveUniformBlockParameter", (void *)webgl2_get_active_uniform_block_parameter},
+    {"getActiveUniformBlockName", (void *)webgl2_get_active_uniform_block_name},
+    {"uniformBlockBinding", (void *)webgl2_uniform_block_binding},
+    {"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},
+    {"compressedTexImage3D", (void *)webgl2_compressed_tex_image3d},
+    {"compressedTexSubImage3D", (void *)webgl2_compressed_tex_sub_image3d},
+    {"clearBufferfi", (void *)webgl2_clear_buffer_fi},
+    {"clearBufferfv", (void *)webgl2_clear_buffer_fv},
+    {"clearBufferiv", (void *)webgl2_clear_buffer_iv},
+    {"clearBufferuiv", (void *)webgl2_clear_buffer_uiv},
+    {"drawBuffers", (void *)webgl2_draw_buffers},
+    {"readBuffer", (void *)webgl2_read_buffer},
+    {"blitFramebuffer", (void *)webgl2_blit_framebuffer},
+    {"framebufferTextureLayer", (void *)webgl2_framebuffer_texture_layer},
+    {"invalidateFramebuffer", (void *)webgl2_invalidate_framebuffer},
+    {"invalidateSubFramebuffer", (void *)webgl2_invalidate_sub_framebuffer},
+    {"getInternalformatParameter", (void *)webgl2_get_internalformat_parameter},
+    {"getFragDataLocation", (void *)webgl2_get_frag_data_location},
+};
+
+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); }
+
+xt_value uint_array(const unsigned int *values, int count) {
+  xt_value array = xt_array_new(0, nullptr);
+  for (int i = 0; i < count; i++) xt_array_push(array, xt_number((double)values[i]));
+  return array;
+}
+
+}  // namespace
+
+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());
+#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);
+  g_webgl2_proto = proto;
+  return proto;
+}
+
+/* -- queries ------------------------------------------------------------- */
+
+METHOD(webgl2_create_query) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_NULL;
+  return webgl_make_object(self, "__xt_gl_query", context->create_query(), "query");
+}
+
+METHOD(webgl2_delete_query) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) context->delete_query(webgl_object_id(xt_arg(argc, argv, 0), "__xt_gl_query"));
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_begin_query) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_end_query) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_get_query) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_NULL;
+}
+
+METHOD(webgl2_get_query_parameter) {
+  (void)env;
+  const int pname = webgl_int(argc, argv, 1, 0);
+  if (pname == GL_QUERY_RESULT_AVAILABLE) return XT_TRUE;
+  if (pname == GL_QUERY_RESULT) return xt_number(0);
+  return XT_NULL;
+}
+
+/* -- transform feedback -------------------------------------------------- */
+
+METHOD(webgl2_create_transform_feedback) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_NULL;
+}
+
+#define WEBGL2_NOOP(name)                     \
+  METHOD(name) {                              \
+    (void)self;                               \
+    (void)env;                                \
+    (void)argc;                               \
+    (void)argv;                               \
+    return XT_UNDEFINED;                      \
+  }
+
+WEBGL2_NOOP(webgl2_delete_transform_feedback)
+WEBGL2_NOOP(webgl2_bind_transform_feedback)
+WEBGL2_NOOP(webgl2_begin_transform_feedback)
+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_get_transform_feedback_varying) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_NULL;
+}
+
+/* -- fences -------------------------------------------------------------- */
+
+METHOD(webgl2_fence_sync) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_NULL;
+  return webgl_make_object(self, "__xt_gl_sync", context->create_sync(), "sync");
+}
+
+METHOD(webgl2_delete_sync) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) context->delete_sync(webgl_object_id(xt_arg(argc, argv, 0), "__xt_gl_sync"));
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_client_wait_sync) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_number(GL_ALREADY_SIGNALED);
+}
+
+METHOD(webgl2_wait_sync) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_get_sync_parameter) {
+  (void)env;
+  const int pname = webgl_int(argc, argv, 1, 0);
+  if (pname == GL_SYNC_STATUS) return xt_number(GL_SIGNALED);
+  return XT_NULL;
+}
+
+/* -- 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;
+  (void)argc;
+  (void)argv;
+  return xt_array_new(0, nullptr);
+}
+
+METHOD(webgl2_get_active_uniforms) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_array_new(0, nullptr);
+}
+
+METHOD(webgl2_get_uniform_block_index) {
+  (void)env;
+  const xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return xt_number(4294967295.0);
+  const uint32_t program = webgl_object_id(xt_arg(argc, argv, 0), "__xt_gl_program");
+  const uint32_t index =
+      context->uniform_block_index(program, webgl_string(argc, argv, 1));
+  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 ------------------------------------------------------------- */
+
+METHOD(webgl2_copy_buffer_sub_data) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->copy_buffer_sub_data(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0),
+                                  (uint32_t)webgl_number(argc, argv, 2, 0.0),
+                                  (uint32_t)webgl_number(argc, argv, 3, 0.0),
+                                  (uint32_t)webgl_number(argc, argv, 4, 0.0));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_get_buffer_sub_data) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const int target = webgl_int(argc, argv, 0, 0);
+  const uint32_t offset = (uint32_t)webgl_number(argc, argv, 1, 0.0);
+  xt_value destination = xt_arg(argc, argv, 2);
+  const uint32_t destination_offset = (uint32_t)webgl_number(argc, argv, 3, 0.0);
+  uint32_t length = (uint32_t)webgl_number(argc, argv, 4, 0.0);
+  std::vector<uint8_t> existing = webgl_bytes(destination);
+  if (destination_offset > existing.size()) return XT_UNDEFINED;
+  if (length == 0) length = (uint32_t)(existing.size() - destination_offset);
+  std::vector<uint8_t> data(length);
+  if (!context->get_buffer_sub_data(target, offset, data.data(), length)) return XT_UNDEFINED;
+  if (destination_offset + length > existing.size()) existing.resize(destination_offset + length);
+  memcpy(existing.data() + destination_offset, data.data(), length);
+  webgl_write_bytes(destination, existing.data(), existing.size());
+  return XT_UNDEFINED;
+}
+
+/* -- textures ------------------------------------------------------------ */
+
+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));
+  }
+  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)
+
+/* -- clears and draw buffers --------------------------------------------- */
+
+METHOD(webgl2_clear_buffer_fv) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const std::vector<double> values = webgl_numbers(xt_arg(argc, argv, 2));
+  float floats[4] = {0, 0, 0, 1};
+  for (size_t i = 0; i < values.size() && i < 4; i++) floats[i] = (float)values[i];
+  context->clear_buffer_float(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0), floats,
+                              (int)values.size());
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_clear_buffer_iv) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const std::vector<double> values = webgl_numbers(xt_arg(argc, argv, 2));
+  int ints[4] = {0, 0, 0, 1};
+  for (size_t i = 0; i < values.size() && i < 4; i++) ints[i] = (int)values[i];
+  context->clear_buffer_int(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0), ints,
+                            (int)values.size());
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_clear_buffer_uiv) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_UNDEFINED;
+  const std::vector<double> values = webgl_numbers(xt_arg(argc, argv, 2));
+  unsigned int uints[4] = {0, 0, 0, 1};
+  for (size_t i = 0; i < values.size() && i < 4; i++) uints[i] = (unsigned int)values[i];
+  context->clear_buffer_uint(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0), uints,
+                             (int)values.size());
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_clear_buffer_fi) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->clear_buffer_fi(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0),
+                             (float)webgl_number(argc, argv, 2, 1.0),
+                             webgl_int(argc, argv, 3, 0));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_draw_buffers) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_UNDEFINED;
+}
+
+/* -- misc ---------------------------------------------------------------- */
+
+METHOD(webgl2_get_internalformat_parameter) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_array_new(0, nullptr);
+}
+
+METHOD(webgl2_get_frag_data_location) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_number(-1);
+}
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_webgl2_draw.cpp

@@ -0,0 +1,269 @@
+/*
+ * xbintsc GUI engine — WebGL 2 draw-side bindings.
+ *
+ * Vertex-array objects, instanced draws, integer attributes, unsigned integer
+ * uniforms and sampler objects. The heavy lifting lives in `webgl_draw.cpp` /
+ * `webgl_webgl2.cpp`; these are the DOM-facing wrappers.
+ */
+
+#include "dom_api_internal.h"
+
+#include <string>
+#include <vector>
+
+#include "webgl.h"
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+namespace domapi {
+namespace {
+
+xtgui::WebGLContext *context_of(xt_value self) { return webgl_from_context(self); }
+
+uint32_t vertex_array_argument(xt_value value) {
+  return webgl_object_id(value, "__xt_gl_vertex_array");
+}
+
+uint32_t sampler_argument(xt_value value) {
+  return webgl_object_id(value, "__xt_gl_sampler");
+}
+
+}  // namespace
+
+/* -- vertex arrays ------------------------------------------------------- */
+
+METHOD(webgl2_create_vertex_array) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_NULL;
+  return webgl_make_object(self, "__xt_gl_vertex_array", context->create_vertex_array(),
+                           "vertexarray");
+}
+
+METHOD(webgl2_delete_vertex_array) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) context->delete_vertex_array(vertex_array_argument(xt_arg(argc, argv, 0)));
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_bind_vertex_array) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->bind_vertex_array(vertex_array_argument(xt_arg(argc, argv, 0)));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_is_vertex_array) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  return xt_bool(context != nullptr &&
+                 context->is_vertex_array(vertex_array_argument(xt_arg(argc, argv, 0))));
+}
+
+/* -- integer attributes and instancing ----------------------------------- */
+
+METHOD(webgl2_vertex_attrib_ipointer) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->attrib_ipointer(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 4),
+                             webgl_int(argc, argv, 2, GL_INT), webgl_int(argc, argv, 3, 0),
+                             webgl_int(argc, argv, 4, 0));
+  }
+  return XT_UNDEFINED;
+}
+
+namespace {
+
+void attrib_integer(xt_value self, int32_t argc, xt_value *argv, bool is_unsigned) {
+  xtgui::WebGLContext *context = webgl_from_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));
+  if (numbers.size() >= 4) {
+    for (int i = 0; i < 4; i++) values[i] = (float)numbers[(size_t)i];
+  } else {
+    for (int i = 0; i < 4; i++) values[i] = (float)webgl_number(argc, argv, i + 1, 0.0);
+  }
+  (void)is_unsigned;
+  context->attrib_value(webgl_int(argc, argv, 0, 0), 4, values);
+}
+
+}  // namespace
+
+METHOD(webgl2_vertex_attrib_i4i) {
+  attrib_integer(self, argc, argv, false);
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_vertex_attrib_i4iv) {
+  attrib_integer(self, argc, argv, false);
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_vertex_attrib_i4ui) {
+  attrib_integer(self, argc, argv, true);
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_vertex_attrib_i4uiv) {
+  attrib_integer(self, argc, argv, true);
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_vertex_attrib_divisor) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->attrib_divisor(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_draw_arrays_instanced) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->draw_arrays_instanced(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0),
+                                   webgl_int(argc, argv, 2, 0), webgl_int(argc, argv, 3, 1));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_draw_elements_instanced) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->draw_elements_instanced(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0),
+                                     webgl_int(argc, argv, 2, 0), webgl_int(argc, argv, 3, 0),
+                                     webgl_int(argc, argv, 4, 1));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_draw_range_elements) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->draw_range_elements(webgl_int(argc, argv, 0, 0), webgl_int(argc, argv, 1, 0),
+                                 webgl_int(argc, argv, 2, 0), webgl_int(argc, argv, 3, 0),
+                                 webgl_int(argc, argv, 4, 0), webgl_int(argc, argv, 5, 0));
+  }
+  return XT_UNDEFINED;
+}
+
+/* -- unsigned integer uniforms ------------------------------------------ */
+
+namespace {
+
+void uniform_unsigned(xt_value self, int32_t argc, xt_value *argv, int components, bool vector) {
+  xtgui::WebGLContext *context = webgl_from_context(self);
+  if (context == nullptr) return;
+  xt_value handle = xt_arg(argc, argv, 0);
+  if (!XT_IS_OBJECT(handle)) return;
+  xt_value program_value = xt_object_get_cstr(handle, "__xt_gl_program");
+  xt_value location_value = xt_object_get_cstr(handle, "__xt_gl_location");
+  if (!XT_IS_NUMBER(program_value) || !XT_IS_NUMBER(location_value)) return;
+  const uint32_t program = (uint32_t)xt_to_number(program_value);
+  const int location = (int)xt_to_number(location_value);
+  if (vector) {
+    const std::vector<double> numbers =
+        webgl_numbers(argc > 1 ? xt_arg(argc, argv, 1) : XT_UNDEFINED);
+    if (numbers.empty()) return;
+    std::vector<int> values(numbers.size());
+    for (size_t i = 0; i < numbers.size(); i++) values[i] = (int)(unsigned int)numbers[i];
+    context->uniform_ints(program, location, components, values.data(),
+                          (int)(numbers.size() / components));
+    return;
+  }
+  int values[4] = {0, 0, 0, 0};
+  for (int i = 0; i < components; i++) {
+    values[i] = (int)(unsigned int)webgl_number(argc, argv, i + 1, 0.0);
+  }
+  context->uniform_ints(program, location, components, values, 1);
+}
+
+}  // namespace
+
+METHOD(webgl2_uniform1ui) {
+  uniform_unsigned(self, argc, argv, 1, false);
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_uniform2ui) {
+  uniform_unsigned(self, argc, argv, 2, false);
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_uniform3ui) {
+  uniform_unsigned(self, argc, argv, 3, false);
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_uniform4ui) {
+  uniform_unsigned(self, argc, argv, 4, false);
+  return XT_UNDEFINED;
+}
+
+/* -- sampler objects ----------------------------------------------------- */
+
+METHOD(webgl2_create_sampler) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_NULL;
+  return webgl_make_object(self, "__xt_gl_sampler", context->create_sampler(), "sampler");
+}
+
+METHOD(webgl2_delete_sampler) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) context->delete_sampler(sampler_argument(xt_arg(argc, argv, 0)));
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_bind_sampler) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->bind_sampler(webgl_int(argc, argv, 0, 0), sampler_argument(xt_arg(argc, argv, 1)));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_sampler_parameteri) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->sampler_parameter(sampler_argument(xt_arg(argc, argv, 0)),
+                               webgl_int(argc, argv, 1, 0), webgl_int(argc, argv, 2, 0));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_sampler_parameterf) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context != nullptr) {
+    context->sampler_parameter(sampler_argument(xt_arg(argc, argv, 0)),
+                               webgl_int(argc, argv, 1, 0),
+                               (int)webgl_number(argc, argv, 2, 0.0));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(webgl2_get_sampler_parameter) {
+  (void)env;
+  xtgui::WebGLContext *context = context_of(self);
+  if (context == nullptr) return XT_NULL;
+  return xt_number(context->sampler_parameter_value(sampler_argument(xt_arg(argc, argv, 0)),
+                                                    webgl_int(argc, argv, 1, 0)));
+}
+
+}  // namespace domapi