@nativescript/canvas 2.0.0-alpha.9 → 2.0.0-beta.0

package/platforms/ios/CanvasNative.xcframework/ios-arm64_x86_64-simulator/CanvasNative.framework/Headers/canvas_native.h

@@ -1,5 +1,5 @@
-#ifndef CBINDGEN_BINDINGS_H
-#define CBINDGEN_BINDINGS_H
+#ifndef CANVAS_C_H
+#define CANVAS_C_H
 
 /* Warning, this file is autogenerated by cbindgen. Don't modify this manually. */
 
@@ -8,89 +8,2829 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-long long canvas_native_init_ios_gl(int64_t view,
+typedef enum GLConstants {
+  UNPACK_FLIP_Y_WEBGL = 37440,
+  UNPACK_PREMULTIPLY_ALPHA_WEBGL = 37441,
+  UNPACK_COLORSPACE_CONVERSION_WEBGL = 37443,
+} GLConstants;
+
+typedef enum ImageBitmapColorSpaceConversion {
+  ImageBitmapColorSpaceConversionDefault,
+  ImageBitmapColorSpaceConversionNone,
+} ImageBitmapColorSpaceConversion;
+
+typedef enum ImageBitmapPremultiplyAlpha {
+  ImageBitmapPremultiplyAlphaDefault,
+  ImageBitmapPremultiplyAlphaPremultiply,
+  ImageBitmapPremultiplyAlphaNone,
+} ImageBitmapPremultiplyAlpha;
+
+typedef enum ImageBitmapResizeQuality {
+  ImageBitmapResizeQualityLow,
+  ImageBitmapResizeQualityMedium,
+  ImageBitmapResizeQualityHigh,
+  ImageBitmapResizeQualityPixelated,
+} ImageBitmapResizeQuality;
+
+typedef enum InvalidateState {
+  InvalidateStateNone,
+  InvalidateStatePending,
+  InvalidateStateInvalidating,
+} InvalidateState;
+
+typedef enum PaintStyleType {
+  PaintStyleTypeNone,
+  PaintStyleTypeColor,
+  PaintStyleTypeGradient,
+  PaintStyleTypePattern,
+} PaintStyleType;
+
+typedef enum TextBaseLine {
+  TOP = 0,
+  HANGING = 1,
+  MIDDLE = 2,
+  ALPHABETIC = 3,
+  IDEOGRAPHIC = 4,
+  BOTTOM = 5,
+} TextBaseLine;
+
+typedef enum WebGLExtensionType {
+  WebGLExtensionTypeEXT_blend_minmax,
+  WebGLExtensionTypeEXT_color_buffer_half_float,
+  WebGLExtensionTypeEXT_disjoint_timer_query,
+  WebGLExtensionTypeEXT_sRGB,
+  WebGLExtensionTypeEXT_shader_texture_lod,
+  WebGLExtensionTypeEXT_texture_filter_anisotropic,
+  WebGLExtensionTypeOES_element_index_uint,
+  WebGLExtensionTypeOES_standard_derivatives,
+  WebGLExtensionTypeOES_texture_float,
+  WebGLExtensionTypeOES_texture_float_linear,
+  WebGLExtensionTypeOES_texture_half_float,
+  WebGLExtensionTypeOES_texture_half_float_linear,
+  WebGLExtensionTypeOES_vertex_array_object,
+  WebGLExtensionTypeWEBGL_color_buffer_float,
+  WebGLExtensionTypeWEBGL_compressed_texture_atc,
+  WebGLExtensionTypeWEBGL_compressed_texture_etc1,
+  WebGLExtensionTypeWEBGL_compressed_texture_s3tc,
+  WebGLExtensionTypeWEBGL_compressed_texture_s3tc_srgb,
+  WebGLExtensionTypeWEBGL_compressed_texture_etc,
+  WebGLExtensionTypeWEBGL_compressed_texture_pvrtc,
+  WebGLExtensionTypeWEBGL_lose_context,
+  WebGLExtensionTypeANGLE_instanced_arrays,
+  WebGLExtensionTypeWEBGL_depth_texture,
+  WebGLExtensionTypeWEBGL_draw_buffers,
+  WebGLExtensionTypeOES_fbo_render_mipmap,
+  WebGLExtensionTypeNone,
+} WebGLExtensionType;
+
+typedef enum WebGLResultType {
+  WebGLResultTypeBoolean,
+  WebGLResultTypeI32Array,
+  WebGLResultTypeU32Array,
+  WebGLResultTypeF32Array,
+  WebGLResultTypeBooleanArray,
+  WebGLResultTypeU32,
+  WebGLResultTypeI32,
+  WebGLResultTypeF32,
+  WebGLResultTypeString,
+  WebGLResultTypeNone,
+} WebGLResultType;
+
+typedef struct ANGLE_instanced_arrays ANGLE_instanced_arrays;
+
+typedef struct CCow CCow;
+
+typedef struct CanvasRenderingContext2D CanvasRenderingContext2D;
+
+typedef struct ContextAttributes ContextAttributes;
+
+typedef struct EXT_blend_minmax EXT_blend_minmax;
+
+typedef struct EXT_color_buffer_half_float EXT_color_buffer_half_float;
+
+typedef struct EXT_disjoint_timer_query EXT_disjoint_timer_query;
+
+typedef struct EXT_shader_texture_lod EXT_shader_texture_lod;
+
+typedef struct EXT_texture_filter_anisotropic EXT_texture_filter_anisotropic;
+
+typedef struct F32Buffer F32Buffer;
+
+typedef struct FileHelper FileHelper;
+
+typedef struct I32Buffer I32Buffer;
+
+typedef struct ImageAsset ImageAsset;
+
+typedef struct ImageData ImageData;
+
+typedef struct ImageFilter ImageFilter;
+
+typedef struct Matrix Matrix;
+
+typedef struct OES_element_index_uint OES_element_index_uint;
+
+typedef struct OES_standard_derivatives OES_standard_derivatives;
+
+typedef struct OES_texture_float OES_texture_float;
+
+typedef struct OES_texture_float_linear OES_texture_float_linear;
+
+typedef struct OES_texture_half_float OES_texture_half_float;
+
+typedef struct OES_texture_half_float_linear OES_texture_half_float_linear;
+
+typedef struct OES_vertex_array_object OES_vertex_array_object;
+
+typedef struct PaintStyle PaintStyle;
+
+typedef struct Path Path;
+
+#if (defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS))
+typedef struct Raf Raf;
+#endif
+
+#if ((defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS)) && defined(TARGET_OS_ANDROID))
+typedef struct Raf Raf;
+#endif
+
+#if ((defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS)) && defined(TARGET_OS_IOS))
+typedef struct Raf Raf;
+#endif
+
+typedef struct StringBuffer StringBuffer;
+
+typedef struct TextDecoder TextDecoder;
+
+typedef struct TextEncoder TextEncoder;
+
+typedef struct TextMetrics TextMetrics;
+
+typedef struct U16Buffer U16Buffer;
+
+typedef struct U32Buffer U32Buffer;
+
+typedef struct U8Buffer U8Buffer;
+
+typedef struct URL URL;
+
+typedef struct WEBGL_color_buffer_float WEBGL_color_buffer_float;
+
+typedef struct WEBGL_compressed_texture_atc WEBGL_compressed_texture_atc;
+
+typedef struct WEBGL_compressed_texture_etc WEBGL_compressed_texture_etc;
+
+typedef struct WEBGL_compressed_texture_etc1 WEBGL_compressed_texture_etc1;
+
+typedef struct WEBGL_compressed_texture_pvrtc WEBGL_compressed_texture_pvrtc;
+
+typedef struct WEBGL_compressed_texture_s3tc WEBGL_compressed_texture_s3tc;
+
+typedef struct WEBGL_compressed_texture_s3tc_srgb WEBGL_compressed_texture_s3tc_srgb;
+
+typedef struct WEBGL_depth_texture WEBGL_depth_texture;
+
+typedef struct WEBGL_draw_buffers WEBGL_draw_buffers;
+
+typedef struct WEBGL_lose_context WEBGL_lose_context;
+
+typedef struct WebGLActiveInfo WebGLActiveInfo;
+
+typedef struct WebGLExtension WebGLExtension;
+
+typedef struct WebGLFramebufferAttachmentParameter WebGLFramebufferAttachmentParameter;
+
+typedef struct WebGLIndexedParameter WebGLIndexedParameter;
+
+typedef struct WebGLResult WebGLResult;
+
+typedef struct WebGLShaderPrecisionFormat WebGLShaderPrecisionFormat;
+
+typedef struct WebGLState WebGLState;
+
+typedef struct WebGLSync WebGLSync;
+
+void canvas_native_image_filter_destroy(struct ImageFilter *value);
+
+void canvas_native_font_add_family(const char *alias,
+                                   const char *const *filenames,
+                                   uintptr_t length);
+
+void canvas_native_helper_destroy(struct FileHelper *value);
+
+struct FileHelper *canvas_native_helper_read_file(const char *path);
+
+bool canvas_native_helper_read_file_has_error(const struct FileHelper *file);
+
+struct U8Buffer *canvas_native_helper_read_file_get_data(struct FileHelper *file);
+
+const char *canvas_native_helper_read_file_get_error(const struct FileHelper *file);
+
+void canvas_native_text_encoder_destroy(struct TextEncoder *value);
+
+void canvas_native_text_decoder_destroy(struct TextDecoder *value);
+
+void canvas_native_context_destroy(struct CanvasRenderingContext2D *value);
+
+void canvas_native_paint_style_destroy(struct PaintStyle *value);
+
+void canvas_native_text_metrics_destroy(struct TextMetrics *value);
+
+#if (defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS))
+struct Raf *canvas_native_raf_create(intptr_t callback, void (*on_frame_callback)(intptr_t callback,
+                                                                                  int64_t ts));
+#endif
+
+#if (defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS))
+void canvas_native_raf_destroy(struct Raf *value);
+#endif
+
+#if (defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS))
+void canvas_native_raf_start(struct Raf *raf);
+#endif
+
+#if (defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS))
+void canvas_native_raf_stop(struct Raf *raf);
+#endif
+
+#if (defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS))
+bool canvas_native_raf_get_started(const struct Raf *raf);
+#endif
+
+struct CanvasRenderingContext2D *canvas_native_context_create_with_wrapper(int64_t context,
+                                                                           int64_t gl_context);
+
+void canvas_native_context_resize(struct CanvasRenderingContext2D *context,
+                                  float width,
+                                  float height);
+
+struct CanvasRenderingContext2D *canvas_native_context_create(float width,
+                                                              float height,
+                                                              float density,
+                                                              bool alpha,
+                                                              int32_t font_color,
+                                                              float ppi,
+                                                              uint32_t direction);
+
+struct CanvasRenderingContext2D *canvas_native_context_create_gl(float width,
+                                                                 float height,
+                                                                 float density,
+                                                                 int64_t gl_context,
+                                                                 int32_t samples,
+                                                                 bool alpha,
+                                                                 int32_t font_color,
+                                                                 float ppi,
+                                                                 uint32_t direction);
+
+struct CanvasRenderingContext2D *canvas_native_context_create_with_pointer(int64_t pointer);
+
+struct CanvasRenderingContext2D *canvas_native_context_create_gl_no_window(float width,
+                                                                           float height,
+                                                                           float density,
+                                                                           int32_t font_color,
+                                                                           float ppi,
+                                                                           uint32_t direction,
+                                                                           bool alpha);
+
+const char *canvas_native_context_get_filter(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_filter(struct CanvasRenderingContext2D *context, const char *filter);
+
+const char *canvas_native_context_get_font(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_font(struct CanvasRenderingContext2D *context, const char *font);
+
+const char *canvas_native_context_get_letter_spacing(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_letter_spacing(struct CanvasRenderingContext2D *context,
+                                              const char *spacing);
+
+const char *canvas_native_context_get_word_spacing(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_word_spacing(struct CanvasRenderingContext2D *context,
+                                            const char *spacing);
+
+float canvas_native_context_get_global_alpha(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_global_alpha(struct CanvasRenderingContext2D *context, float alpha);
+
+bool canvas_native_context_get_image_smoothing_enabled(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_image_smoothing_enabled(struct CanvasRenderingContext2D *context,
+                                                       bool enabled);
+
+const char *canvas_native_context_get_image_smoothing_quality(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_image_smoothing_quality(struct CanvasRenderingContext2D *context,
+                                                       const char *quality);
+
+const char *canvas_native_context_get_line_join(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_line_join(struct CanvasRenderingContext2D *context,
+                                         const char *join);
+
+const char *canvas_native_context_get_line_cap(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_line_cap(struct CanvasRenderingContext2D *context, const char *cap);
+
+float canvas_native_context_get_miter_limit(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_miter_limit(struct CanvasRenderingContext2D *context, float limit);
+
+const char *canvas_native_context_get_shadow_color(const struct CanvasRenderingContext2D *context);
+
+struct U8Buffer *canvas_native_context_get_shadow_color_buf(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_get_shadow_color_rgba(const struct CanvasRenderingContext2D *context,
+                                                 uint8_t *r,
+                                                 uint8_t *g,
+                                                 uint8_t *b,
+                                                 uint8_t *a);
+
+void canvas_native_context_set_shadow_color(struct CanvasRenderingContext2D *context,
+                                            const char *color);
+
+void canvas_native_context_set_shadow_color_rgba(struct CanvasRenderingContext2D *context,
+                                                 uint8_t r,
+                                                 uint8_t g,
+                                                 uint8_t b,
+                                                 uint8_t a);
+
+float canvas_native_context_get_shadow_blur(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_shadow_blur(struct CanvasRenderingContext2D *context, float blur);
+
+float canvas_native_context_get_shadow_offset_x(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_shadow_offset_x(struct CanvasRenderingContext2D *context, float x);
+
+float canvas_native_context_get_shadow_offset_y(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_shadow_offset_y(struct CanvasRenderingContext2D *context, float y);
+
+const char *canvas_native_context_get_text_align(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_text_align(struct CanvasRenderingContext2D *context,
+                                          const char *alignment);
+
+const char *canvas_native_context_get_text_baseline_str(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_text_baseline_str(struct CanvasRenderingContext2D *context,
+                                                 const char *baseline);
+
+void canvas_native_context_set_text_baseline(struct CanvasRenderingContext2D *context,
+                                             enum TextBaseLine baseline);
+
+enum TextBaseLine canvas_native_context_get_text_baseline(const struct CanvasRenderingContext2D *context);
+
+const char *canvas_native_context_get_global_composition(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_global_composition(struct CanvasRenderingContext2D *context,
+                                                  const char *composition);
+
+void canvas_native_paint_style_set_fill_color_with_c_string(struct CanvasRenderingContext2D *context,
+                                                            const char *color);
+
+void canvas_native_paint_style_set_stroke_color_with_c_string(struct CanvasRenderingContext2D *context,
+                                                              const char *color);
+
+void canvas_native_paint_style_set_stroke_color_with_rgba(struct CanvasRenderingContext2D *context,
+                                                          uint8_t r,
+                                                          uint8_t g,
+                                                          uint8_t b,
+                                                          uint8_t a);
+
+void canvas_native_paint_style_set_fill_color_with_rgba(struct CanvasRenderingContext2D *context,
+                                                        uint8_t r,
+                                                        uint8_t g,
+                                                        uint8_t b,
+                                                        uint8_t a);
+
+bool canvas_native_parse_css_color_rgba(const char *value,
+                                        uint8_t *r,
+                                        uint8_t *g,
+                                        uint8_t *b,
+                                        uint8_t *a);
+
+const char *canvas_native_paint_style_get_color_string(const struct PaintStyle *color);
+
+const char *canvas_native_paint_style_get_current_stroke_color_string(const struct CanvasRenderingContext2D *context);
+
+struct U8Buffer *canvas_native_paint_style_get_current_stroke_color_buf(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_paint_style_get_current_stroke_color_r_g_b_a(const struct CanvasRenderingContext2D *context,
+                                                                uint8_t *r,
+                                                                uint8_t *g,
+                                                                uint8_t *b,
+                                                                uint8_t *a);
+
+void canvas_native_paint_style_get_current_fill_color_r_g_b_a(const struct CanvasRenderingContext2D *context,
+                                                              uint8_t *r,
+                                                              uint8_t *g,
+                                                              uint8_t *b,
+                                                              uint8_t *a);
+
+const char *canvas_native_paint_style_get_current_fill_color_string(const struct CanvasRenderingContext2D *context);
+
+struct U8Buffer *canvas_native_paint_style_get_current_fill_color_buf(struct CanvasRenderingContext2D *context);
+
+enum PaintStyleType canvas_native_context_get_style_type(const struct PaintStyle *style);
+
+enum PaintStyleType canvas_native_context_get_current_fill_style_type(struct CanvasRenderingContext2D *context);
+
+enum PaintStyleType canvas_native_context_get_current_stroke_style_type(struct CanvasRenderingContext2D *context);
+
+struct PaintStyle *canvas_native_context_get_fill_style(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_fill_style(struct CanvasRenderingContext2D *context,
+                                          const struct PaintStyle *style);
+
+struct PaintStyle *canvas_native_context_get_stroke_style(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_stroke_style(struct CanvasRenderingContext2D *context,
+                                            const struct PaintStyle *style);
+
+float canvas_native_context_get_line_width(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_line_width(struct CanvasRenderingContext2D *context, float width);
+
+float canvas_native_context_get_line_dash_offset(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_line_dash_offset(struct CanvasRenderingContext2D *context,
+                                                float offset);
+
+struct F32Buffer *canvas_native_context_get_line_dash(const struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_set_line_dash(struct CanvasRenderingContext2D *context,
+                                         const float *dash,
+                                         uintptr_t size);
+
+void canvas_native_context_arc(struct CanvasRenderingContext2D *context,
+                               float x,
+                               float y,
+                               float radius,
+                               float start_angle,
+                               float end_angle,
+                               bool anticlockwise);
+
+void canvas_native_context_arc_to(struct CanvasRenderingContext2D *context,
+                                  float x1,
+                                  float y1,
+                                  float x2,
+                                  float y2,
+                                  float radius);
+
+void canvas_native_context_begin_path(struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_bezier_curve_to(struct CanvasRenderingContext2D *context,
+                                           float cp1x,
+                                           float cp1y,
+                                           float cp2x,
+                                           float cp2y,
+                                           float x,
+                                           float y);
+
+void canvas_native_context_clear_rect(struct CanvasRenderingContext2D *context,
+                                      float x,
+                                      float y,
+                                      float width,
+                                      float height);
+
+void canvas_native_context_clip_str(struct CanvasRenderingContext2D *context,
+                                    struct Path *path,
+                                    const char *rule);
+
+void canvas_native_context_clip_rule_str(struct CanvasRenderingContext2D *context,
+                                         const char *rule);
+
+void canvas_native_context_clip(struct CanvasRenderingContext2D *context,
+                                struct Path *path,
+                                uint32_t rule);
+
+void canvas_native_context_clip_rule(struct CanvasRenderingContext2D *context, uint32_t rule);
+
+void canvas_native_context_close_path(struct CanvasRenderingContext2D *context);
+
+struct ImageData *canvas_native_context_create_image_data(int32_t width, int32_t height);
+
+struct ImageData *canvas_native_context_create_image_data_with_data(int32_t width,
+                                                                    int32_t height,
+                                                                    const uint8_t *data,
+                                                                    uintptr_t size);
+
+struct PaintStyle *canvas_native_context_create_linear_gradient(struct CanvasRenderingContext2D *context,
+                                                                float x0,
+                                                                float y0,
+                                                                float x1,
+                                                                float y1);
+
+struct PaintStyle *canvas_native_context_create_conic_gradient(struct CanvasRenderingContext2D *context,
+                                                               float start_angle,
+                                                               float x,
+                                                               float y);
+
+struct PaintStyle *canvas_native_context_create_pattern(struct CanvasRenderingContext2D *context,
+                                                        const uint8_t *data,
+                                                        uintptr_t size,
+                                                        int32_t width,
+                                                        int32_t height,
+                                                        const char *repetition);
+
+struct PaintStyle *canvas_native_context_create_pattern_asset(struct CanvasRenderingContext2D *context,
+                                                              struct ImageAsset *asset,
+                                                              const char *repetition);
+
+struct PaintStyle *canvas_native_context_create_pattern_encoded(struct CanvasRenderingContext2D *context,
+                                                                const uint8_t *data,
+                                                                uintptr_t size,
+                                                                const char *repetition);
+
+struct PaintStyle *canvas_native_context_create_pattern_canvas2d(struct CanvasRenderingContext2D *source,
+                                                                 struct CanvasRenderingContext2D *context,
+                                                                 const char *repetition);
+
+struct PaintStyle *canvas_native_context_create_radial_gradient(struct CanvasRenderingContext2D *context,
+                                                                float x0,
+                                                                float y0,
+                                                                float r0,
+                                                                float x1,
+                                                                float y1,
+                                                                float r1);
+
+void canvas_native_context_draw_paint(struct CanvasRenderingContext2D *context, const char *color);
+
+void canvas_native_context_draw_point(struct CanvasRenderingContext2D *context, float x, float y);
+
+void canvas_native_context_draw_points(struct CanvasRenderingContext2D *context,
+                                       int32_t mode,
+                                       const float *points,
+                                       uintptr_t size);
+
+void canvas_native_context_draw_image_dx_dy(struct CanvasRenderingContext2D *context,
+                                            const uint8_t *data,
+                                            uintptr_t size,
+                                            float width,
+                                            float height,
+                                            float dx,
+                                            float dy);
+
+void canvas_native_context_draw_image_dx_dy_dw_dh(struct CanvasRenderingContext2D *context,
+                                                  const uint8_t *data,
+                                                  uintptr_t size,
+                                                  float width,
+                                                  float height,
+                                                  float dx,
+                                                  float dy,
+                                                  float d_width,
+                                                  float d_height);
+
+void canvas_native_context_draw_image(struct CanvasRenderingContext2D *context,
+                                      const uint8_t *data,
+                                      uintptr_t size,
+                                      float width,
+                                      float height,
+                                      float sx,
+                                      float sy,
+                                      float s_width,
+                                      float s_height,
+                                      float dx,
+                                      float dy,
+                                      float d_width,
+                                      float d_height);
+
+void canvas_native_context_draw_image_encoded_dx_dy(struct CanvasRenderingContext2D *context,
+                                                    const uint8_t *data,
+                                                    uintptr_t size,
+                                                    float dx,
+                                                    float dy);
+
+void canvas_native_context_draw_image_encoded_dx_dy_dw_dh(struct CanvasRenderingContext2D *context,
+                                                          const uint8_t *data,
+                                                          uintptr_t size,
+                                                          float dx,
+                                                          float dy,
+                                                          float d_width,
+                                                          float d_height);
+
+void canvas_native_context_draw_image_encoded(struct CanvasRenderingContext2D *context,
+                                              const uint8_t *data,
+                                              uintptr_t size,
+                                              float sx,
+                                              float sy,
+                                              float s_width,
+                                              float s_height,
+                                              float dx,
+                                              float dy,
+                                              float d_width,
+                                              float d_height);
+
+void canvas_native_context_draw_image_dx_dy_asset(struct CanvasRenderingContext2D *context,
+                                                  struct ImageAsset *asset,
+                                                  float dx,
+                                                  float dy);
+
+void canvas_native_context_draw_image_dx_dy_dw_dh_asset(struct CanvasRenderingContext2D *context,
+                                                        struct ImageAsset *asset,
+                                                        float dx,
+                                                        float dy,
+                                                        float d_width,
+                                                        float d_height);
+
+void canvas_native_context_draw_image_asset(struct CanvasRenderingContext2D *context,
+                                            struct ImageAsset *asset,
+                                            float sx,
+                                            float sy,
+                                            float s_width,
+                                            float s_height,
+                                            float dx,
+                                            float dy,
+                                            float d_width,
+                                            float d_height);
+
+void canvas_native_context_draw_image_dx_dy_context(struct CanvasRenderingContext2D *context,
+                                                    struct CanvasRenderingContext2D *source,
+                                                    float dx,
+                                                    float dy);
+
+void canvas_native_context_draw_image_dx_dy_dw_dh_context(struct CanvasRenderingContext2D *context,
+                                                          struct CanvasRenderingContext2D *source,
+                                                          float dx,
+                                                          float dy,
+                                                          float d_width,
+                                                          float d_height);
+
+void canvas_native_context_draw_image_context(struct CanvasRenderingContext2D *context,
+                                              struct CanvasRenderingContext2D *source,
+                                              float sx,
+                                              float sy,
+                                              float s_width,
+                                              float s_height,
+                                              float dx,
+                                              float dy,
+                                              float d_width,
+                                              float d_height);
+
+void canvas_native_context_ellipse(struct CanvasRenderingContext2D *context,
+                                   float x,
+                                   float y,
+                                   float radius_x,
+                                   float radius_y,
+                                   float rotation,
+                                   float start_angle,
+                                   float end_angle,
+                                   bool anticlockwise);
+
+void canvas_native_context_fill_str(struct CanvasRenderingContext2D *context, const char *rule);
+
+void canvas_native_context_fill_with_path_str(struct CanvasRenderingContext2D *context,
+                                              struct Path *path,
+                                              const char *rule);
+
+void canvas_native_context_fill(struct CanvasRenderingContext2D *context, uint32_t rule);
+
+void canvas_native_context_fill_with_path(struct CanvasRenderingContext2D *context,
+                                          struct Path *path,
+                                          uint32_t rule);
+
+void canvas_native_context_fill_rect(struct CanvasRenderingContext2D *context,
+                                     float x,
+                                     float y,
+                                     float width,
+                                     float height);
+
+void canvas_native_context_fill_text(struct CanvasRenderingContext2D *context,
+                                     const char *text,
+                                     float x,
+                                     float y);
+
+void canvas_native_context_fill_text_width(struct CanvasRenderingContext2D *context,
+                                           const char *text,
+                                           float x,
+                                           float y,
+                                           float width);
+
+struct ImageData *canvas_native_context_get_image_data(struct CanvasRenderingContext2D *context,
+                                                       float sx,
+                                                       float sy,
+                                                       float sw,
+                                                       float sh);
+
+struct Matrix *canvas_native_context_get_transform(struct CanvasRenderingContext2D *context);
+
+bool canvas_native_context_is_point_in_path_str(struct CanvasRenderingContext2D *context,
+                                                float x,
+                                                float y,
+                                                const char *rule);
+
+bool canvas_native_context_is_point_in_path_with_path_str(struct CanvasRenderingContext2D *context,
+                                                          struct Path *path,
+                                                          float x,
+                                                          float y,
+                                                          const char *rule);
+
+bool canvas_native_context_is_point_in_path(struct CanvasRenderingContext2D *context,
+                                            float x,
+                                            float y,
+                                            uint32_t rule);
+
+bool canvas_native_context_is_point_in_path_with_path(struct CanvasRenderingContext2D *context,
+                                                      struct Path *path,
+                                                      float x,
+                                                      float y,
+                                                      uint32_t rule);
+
+bool canvas_native_context_is_point_in_stroke(struct CanvasRenderingContext2D *context,
+                                              float x,
+                                              float y);
+
+bool canvas_native_context_is_point_in_stroke_with_path(struct CanvasRenderingContext2D *context,
+                                                        struct Path *path,
+                                                        float x,
+                                                        float y);
+
+void canvas_native_context_line_to(struct CanvasRenderingContext2D *context, float x, float y);
+
+struct TextMetrics *canvas_native_context_measure_text(struct CanvasRenderingContext2D *context,
+                                                       const char *text);
+
+void canvas_native_context_move_to(struct CanvasRenderingContext2D *context, float x, float y);
+
+void canvas_native_context_put_image_data(struct CanvasRenderingContext2D *context,
+                                          struct ImageData *image_data,
+                                          float dx,
+                                          float dy,
+                                          float dirty_x,
+                                          float dirty_y,
+                                          float dirty_width,
+                                          float dirty_height);
+
+void canvas_native_context_quadratic_curve_to(struct CanvasRenderingContext2D *context,
+                                              float cpx,
+                                              float cpy,
+                                              float x,
+                                              float y);
+
+void canvas_native_context_rect(struct CanvasRenderingContext2D *context,
+                                float x,
+                                float y,
+                                float width,
+                                float height);
+
+void canvas_native_context_round_rect(struct CanvasRenderingContext2D *context,
+                                      float x,
+                                      float y,
+                                      float width,
+                                      float height,
+                                      const float *radii,
+                                      uintptr_t size);
+
+void canvas_native_context_round_rect_tl_tr_br_bl(struct CanvasRenderingContext2D *context,
+                                                  float x,
+                                                  float y,
+                                                  float width,
+                                                  float height,
+                                                  float top_left,
+                                                  float top_right,
+                                                  float bottom_right,
+                                                  float bottom_left);
+
+void canvas_native_context_reset_transform(struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_restore(struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_rotate(struct CanvasRenderingContext2D *context, float angle);
+
+void canvas_native_context_save(struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_scale(struct CanvasRenderingContext2D *context, float x, float y);
+
+void canvas_native_context_set_transform(struct CanvasRenderingContext2D *context,
+                                         float a,
+                                         float b,
+                                         float c,
+                                         float d,
+                                         float e,
+                                         float f);
+
+void canvas_native_context_set_transform_matrix(struct CanvasRenderingContext2D *context,
+                                                struct Matrix *matrix);
+
+void canvas_native_context_stroke(struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_stroke_with_path(struct CanvasRenderingContext2D *context,
+                                            struct Path *path);
+
+void canvas_native_context_stroke_rect(struct CanvasRenderingContext2D *context,
+                                       float x,
+                                       float y,
+                                       float width,
+                                       float height);
+
+void canvas_native_context_stroke_text(struct CanvasRenderingContext2D *context,
+                                       const char *text,
+                                       float x,
+                                       float y);
+
+void canvas_native_context_stroke_text_width(struct CanvasRenderingContext2D *context,
+                                             const char *text,
+                                             float x,
+                                             float y,
+                                             float width);
+
+void canvas_native_context_transform(struct CanvasRenderingContext2D *context,
+                                     float a,
+                                     float b,
+                                     float c,
+                                     float d,
+                                     float e,
+                                     float f);
+
+void canvas_native_context_translate(struct CanvasRenderingContext2D *context, float x, float y);
+
+void canvas_native_context_flush(struct CanvasRenderingContext2D *context);
+
+void canvas_native_context_render(const struct CanvasRenderingContext2D *context);
+
+const char *canvas_native_to_data_url(struct CanvasRenderingContext2D *context,
+                                      const char *format,
+                                      uint32_t quality);
+
+struct ImageAsset *canvas_native_image_bitmap_create_from_asset(struct ImageAsset *asset,
+                                                                bool flip_y,
+                                                                enum ImageBitmapPremultiplyAlpha premultiply_alpha,
+                                                                enum ImageBitmapColorSpaceConversion color_space_conversion,
+                                                                enum ImageBitmapResizeQuality resize_quality,
+                                                                float resize_width,
+                                                                float resize_height);
+
+struct ImageAsset *canvas_native_image_bitmap_create_from_asset_src_rect(struct ImageAsset *asset,
+                                                                         float sx,
+                                                                         float sy,
+                                                                         float s_width,
+                                                                         float s_height,
+                                                                         bool flip_y,
+                                                                         enum ImageBitmapPremultiplyAlpha premultiply_alpha,
+                                                                         enum ImageBitmapColorSpaceConversion color_space_conversion,
+                                                                         enum ImageBitmapResizeQuality resize_quality,
+                                                                         float resize_width,
+                                                                         float resize_height);
+
+struct ImageAsset *canvas_native_image_bitmap_create_from_encoded_bytes(const uint8_t *bytes,
+                                                                        uintptr_t size,
+                                                                        bool flip_y,
+                                                                        enum ImageBitmapPremultiplyAlpha premultiply_alpha,
+                                                                        enum ImageBitmapColorSpaceConversion color_space_conversion,
+                                                                        enum ImageBitmapResizeQuality resize_quality,
+                                                                        float resize_width,
+                                                                        float resize_height);
+
+bool canvas_native_image_bitmap_create_from_encoded_bytes_with_output(const uint8_t *bytes,
+                                                                      uintptr_t size,
+                                                                      bool flip_y,
+                                                                      enum ImageBitmapPremultiplyAlpha premultiply_alpha,
+                                                                      enum ImageBitmapColorSpaceConversion color_space_conversion,
+                                                                      enum ImageBitmapResizeQuality resize_quality,
+                                                                      float resize_width,
+                                                                      float resize_height,
+                                                                      struct ImageAsset *output);
+
+struct ImageAsset *canvas_native_image_bitmap_create_from_encoded_bytes_src_rect(const uint8_t *bytes,
+                                                                                 uintptr_t size,
+                                                                                 float sx,
+                                                                                 float sy,
+                                                                                 float s_width,
+                                                                                 float s_height,
+                                                                                 bool flip_y,
+                                                                                 enum ImageBitmapPremultiplyAlpha premultiply_alpha,
+                                                                                 enum ImageBitmapColorSpaceConversion color_space_conversion,
+                                                                                 enum ImageBitmapResizeQuality resize_quality,
+                                                                                 float resize_width,
+                                                                                 float resize_height);
+
+bool canvas_native_image_bitmap_create_from_encoded_bytes_src_rect_with_output(const uint8_t *bytes,
+                                                                               uintptr_t size,
+                                                                               float sx,
+                                                                               float sy,
+                                                                               float s_width,
+                                                                               float s_height,
+                                                                               bool flip_y,
+                                                                               enum ImageBitmapPremultiplyAlpha premultiply_alpha,
+                                                                               enum ImageBitmapColorSpaceConversion color_space_conversion,
+                                                                               enum ImageBitmapResizeQuality resize_quality,
+                                                                               float resize_width,
+                                                                               float resize_height,
+                                                                               struct ImageAsset *output);
+
+void canvas_native_path_add_path(struct Path *path, const struct Path *path_to_add);
+
+struct Path *canvas_native_path_create(void);
+
+struct Path *canvas_native_path_create_with_path(const struct Path *path);
+
+struct Path *canvas_native_path_create_with_string(const char *string);
+
+void canvas_native_path_close_path(struct Path *path);
+
+void canvas_native_path_move_to(struct Path *path, float x, float y);
+
+void canvas_native_path_line_to(struct Path *path, float x, float y);
+
+void canvas_native_path_bezier_curve_to(struct Path *path,
+                                        float cp1x,
+                                        float cp1y,
+                                        float cp2x,
+                                        float cp2y,
+                                        float x,
+                                        float y);
+
+void canvas_native_path_quadratic_curve_to(struct Path *path,
+                                           float cpx,
+                                           float cpy,
+                                           float x,
+                                           float y);
+
+void canvas_native_path_arc(struct Path *path,
+                            float x,
+                            float y,
+                            float radius,
+                            float start_angle,
+                            float end_angle,
+                            bool anti_clockwise);
+
+void canvas_native_path_arc_to(struct Path *path,
+                               float x1,
+                               float y1,
+                               float x2,
+                               float y2,
+                               float radius);
+
+void canvas_native_path_ellipse(struct Path *path,
+                                float x,
+                                float y,
+                                float radius_x,
+                                float radius_y,
+                                float rotation,
+                                float start_angle,
+                                float end_angle,
+                                bool anticlockwise);
+
+void canvas_native_path_rect(struct Path *path, float x, float y, float width, float height);
+
+void canvas_native_path_round_rect(struct Path *path,
+                                   float x,
+                                   float y,
+                                   float width,
+                                   float height,
+                                   const float *radii,
+                                   uintptr_t size);
+
+void canvas_native_path_round_rect_tl_tr_br_bl(struct Path *path,
+                                               float x,
+                                               float y,
+                                               float width,
+                                               float height,
+                                               float top_left,
+                                               float top_right,
+                                               float bottom_right,
+                                               float bottom_left);
+
+const char *canvas_native_path_to_string(const struct Path *path);
+
+struct Matrix *canvas_native_matrix_create(void);
+
+void canvas_native_matrix_update(struct Matrix *matrix, const float *slice, uintptr_t size);
+
+void canvas_native_matrix_update_3d(struct Matrix *matrix, const float *slice, uintptr_t size);
+
+float canvas_native_matrix_get_a(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_a(struct Matrix *matrix, float a);
+
+float canvas_native_matrix_get_b(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_b(struct Matrix *matrix, float b);
+
+float canvas_native_matrix_get_c(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_c(struct Matrix *matrix, float c);
+
+float canvas_native_matrix_get_d(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_d(struct Matrix *matrix, float d);
+
+float canvas_native_matrix_get_e(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_e(struct Matrix *matrix, float e);
+
+float canvas_native_matrix_get_f(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_f(struct Matrix *matrix, float f);
+
+float canvas_native_matrix_get_m11(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m11(struct Matrix *matrix, float m11);
+
+float canvas_native_matrix_get_m12(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m12(struct Matrix *matrix, float m12);
+
+float canvas_native_matrix_get_m13(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m13(struct Matrix *matrix, float m13);
+
+float canvas_native_matrix_get_m14(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m14(struct Matrix *matrix, float m14);
+
+float canvas_native_matrix_get_m21(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m21(struct Matrix *matrix, float m21);
+
+float canvas_native_matrix_get_m22(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m22(struct Matrix *matrix, float m22);
+
+float canvas_native_matrix_get_m23(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m23(struct Matrix *matrix, float m23);
+
+float canvas_native_matrix_get_m24(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m24(struct Matrix *matrix, float m24);
+
+float canvas_native_matrix_get_m31(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m31(struct Matrix *matrix, float m31);
+
+float canvas_native_matrix_get_m32(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m32(struct Matrix *matrix, float m32);
+
+float canvas_native_matrix_get_m33(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m33(struct Matrix *matrix, float m33);
+
+float canvas_native_matrix_get_m34(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m34(struct Matrix *matrix, float m34);
+
+float canvas_native_matrix_get_m41(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m41(struct Matrix *matrix, float m41);
+
+float canvas_native_matrix_get_m42(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m42(struct Matrix *matrix, float m42);
+
+float canvas_native_matrix_get_m43(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m43(struct Matrix *matrix, float m43);
+
+float canvas_native_matrix_get_m44(const struct Matrix *matrix);
+
+void canvas_native_matrix_set_m44(struct Matrix *matrix, float m44);
+
+struct ImageData *canvas_native_image_data_create(int32_t width, int32_t height);
+
+int32_t canvas_native_image_data_get_width(const struct ImageData *image_data);
+
+int32_t canvas_native_image_data_get_height(const struct ImageData *image_data);
+
+struct U8Buffer *canvas_native_image_data_get_data(struct ImageData *image_data);
+
+struct ImageData *canvas_native_image_data_get_shared_instance(struct ImageData *image_data);
+
+struct ImageAsset *canvas_native_image_asset_create(void);
+
+struct ImageAsset *canvas_native_image_asset_shared_clone(struct ImageAsset *asset);
+
+bool canvas_native_image_asset_load_from_fd(struct ImageAsset *asset, int fd);
+
+bool canvas_native_image_asset_load_from_path(struct ImageAsset *asset, const char *path);
+
+bool canvas_native_image_asset_load_from_raw(struct ImageAsset *asset,
+                                             const uint8_t *array,
+                                             uintptr_t size);
+
+bool canvas_native_image_asset_load_from_url(struct ImageAsset *asset, const char *url);
+
+int64_t canvas_native_image_asset_addr(struct ImageAsset *asset);
+
+uint32_t canvas_native_image_asset_width(struct ImageAsset *asset);
+
+uint32_t canvas_native_image_asset_height(struct ImageAsset *asset);
+
+const char *canvas_native_image_asset_get_error(struct ImageAsset *asset);
+
+bool canvas_native_image_asset_has_error(struct ImageAsset *asset);
+
+bool canvas_native_image_asset_scale(struct ImageAsset *asset, uint32_t x, uint32_t y);
+
+bool canvas_native_image_asset_save_path(struct ImageAsset *asset,
+                                         const char *path,
+                                         uint32_t format);
+
+float canvas_native_text_metrics_get_width(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_actual_bounding_box_left(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_actual_bounding_box_right(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_actual_bounding_box_ascent(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_actual_bounding_box_descent(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_font_bounding_box_ascent(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_font_bounding_box_descent(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_em_height_ascent(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_em_height_descent(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_hanging_baseline(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_alphabetic_baseline(const struct TextMetrics *metrics);
+
+float canvas_native_text_metrics_get_ideographic_baseline(const struct TextMetrics *metrics);
+
+struct PaintStyle *canvas_native_paint_style_from_bytes(const struct CanvasRenderingContext2D *context,
+                                                        int32_t repetition,
+                                                        int32_t width,
+                                                        int32_t height,
+                                                        const uint8_t *bytes,
+                                                        uintptr_t size);
+
+struct PaintStyle *canvas_native_pattern_from_ptr(int64_t ptr);
+
+struct PaintStyle *canvas_native_paint_style_empty(void);
+
+void canvas_native_gradient_add_color_stop(struct PaintStyle *style, float stop, const char *color);
+
+void canvas_native_pattern_set_transform(struct PaintStyle *pattern, const struct Matrix *matrix);
+
+struct TextDecoder *canvas_native_text_decoder_create(const char *decoding);
+
+const char *canvas_native_text_decoder_decode(const struct TextDecoder *decoder,
+                                              const uint8_t *data,
+                                              uintptr_t size);
+
+void canvas_native_ccow_destroy(struct CCow *cow);
+
+const uint8_t *canvas_native_ccow_get_bytes(const struct CCow *cow);
+
+uintptr_t canvas_native_ccow_get_length(const struct CCow *cow);
+
+struct CCow *canvas_native_text_decoder_decode_as_cow(const struct TextDecoder *decoder,
+                                                      const uint8_t *data,
+                                                      uintptr_t size);
+
+struct U8Buffer *canvas_native_text_decoder_decode_as_bytes(const struct TextDecoder *decoder,
+                                                            const uint8_t *data,
+                                                            uintptr_t size);
+
+const char *canvas_native_text_decoder_decode_c_string(const struct TextDecoder *decoder,
+                                                       const char *data);
+
+const char *canvas_native_text_decoder_get_encoding(const struct TextDecoder *decoder);
+
+struct TextEncoder *canvas_native_text_encoder_create(const char *encoding);
+
+struct U8Buffer *canvas_native_text_encoder_encode(const struct TextEncoder *encoder,
+                                                   const char *text);
+
+const char *canvas_native_text_encoder_get_encoding(const struct TextEncoder *encoder);
+
+bool canvas_native_context_gl_make_current(const struct CanvasRenderingContext2D *context);
+
+bool canvas_native_context_gl_swap_buffers(const struct CanvasRenderingContext2D *context);
+
+struct PaintStyle *canvas_native_context_create_pattern_webgl(struct WebGLState *source,
+                                                              struct CanvasRenderingContext2D *context,
+                                                              const char *repetition);
+
+bool canvas_native_webgl_make_current(struct WebGLState *state);
+
+bool canvas_native_webgl_swap_buffers(struct WebGLState *state);
+
+void canvas_native_webgl_resized(struct WebGLState *_state);
+
+const char *canvas_native_webgl_to_data_url(struct WebGLState *state,
+                                            const char *format,
+                                            uint32_t quality);
+
+void canvas_native_webgl_state_destroy(struct WebGLState *state);
+
+void canvas_native_webgl_active_info_destroy(struct WebGLActiveInfo *info);
+
+void canvas_native_context_attributes_destroy(struct ContextAttributes *attr);
+
+void canvas_native_webgl_framebuffer_attachment_parameter_destroy(struct WebGLFramebufferAttachmentParameter *parameter);
+
+void canvas_native_webgl_shader_precision_format_destroy(struct WebGLShaderPrecisionFormat *value);
+
+void canvas_native_webgl_extension_destroy(struct WebGLExtension *value);
+
+void canvas_native_webgl_EXT_blend_minmax_destroy(struct EXT_blend_minmax *value);
+
+void canvas_native_webgl_EXT_color_buffer_half_float_destroy(struct EXT_color_buffer_half_float *value);
+
+void canvas_native_webgl_EXT_disjoint_timer_query_destroy(struct EXT_disjoint_timer_query *value);
+
+void canvas_native_webgl_EXT_sRGB_destroy(struct EXT_disjoint_timer_query *value);
+
+void canvas_native_webgl_EXT_shader_texture_lod_destroy(struct EXT_shader_texture_lod *value);
+
+void canvas_native_webgl_EXT_texture_filter_anisotropic_destroy(struct EXT_texture_filter_anisotropic *value);
+
+void canvas_native_webgl_OES_element_index_uint_destroy(struct OES_element_index_uint *value);
+
+void canvas_native_webgl_OES_standard_derivatives_destroy(struct OES_standard_derivatives *value);
+
+void canvas_native_webgl_OES_texture_float_destroy(struct OES_texture_float *value);
+
+void canvas_native_webgl_OES_texture_float_linear_destroy(struct OES_texture_float_linear *value);
+
+void canvas_native_webgl_OES_texture_half_float_destroy(struct OES_texture_half_float *value);
+
+void canvas_native_webgl_OES_texture_half_float_linear_destroy(struct OES_texture_half_float_linear *value);
+
+void canvas_native_webgl_OES_vertex_array_object_destroy(struct OES_vertex_array_object *value);
+
+void canvas_native_webgl_WEBGL_color_buffer_float_destroy(struct WEBGL_color_buffer_float *value);
+
+void canvas_native_webgl_WEBGL_compressed_texture_atc_destroy(struct WEBGL_compressed_texture_atc *value);
+
+void canvas_native_webgl_WEBGL_compressed_texture_etc1_destroy(struct WEBGL_compressed_texture_etc1 *value);
+
+void canvas_native_webgl_WEBGL_compressed_texture_s3tc_destroy(struct WEBGL_compressed_texture_s3tc *value);
+
+void canvas_native_webgl_WEBGL_compressed_texture_s3tc_srgb_destroy(struct WEBGL_compressed_texture_s3tc_srgb *value);
+
+void canvas_native_webgl_WEBGL_compressed_texture_etc_destroy(struct WEBGL_compressed_texture_etc *value);
+
+void canvas_native_webgl_WEBGL_compressed_texture_pvrtc_destroy(struct WEBGL_compressed_texture_pvrtc *value);
+
+void canvas_native_webgl_WEBGL_lose_context_destroy(struct WEBGL_lose_context *value);
+
+void canvas_native_webgl_ANGLE_instanced_arrays_destroy(struct ANGLE_instanced_arrays *value);
+
+void canvas_native_webgl_WEBGL_depth_texture_destroy(struct WEBGL_depth_texture *value);
+
+void canvas_native_webgl_WEBGL_draw_buffers_destroy(struct WEBGL_draw_buffers *value);
+
+void canvas_native_webgl_WebGLResult_destroy(struct WebGLResult *value);
+
+const char *canvas_native_webgl_active_info_get_name(const struct WebGLActiveInfo *info);
+
+int32_t canvas_native_webgl_active_info_get_size(const struct WebGLActiveInfo *info);
+
+uint32_t canvas_native_webgl_active_info_get_type(const struct WebGLActiveInfo *info);
+
+bool canvas_native_webgl_active_info_get_is_empty(const struct WebGLActiveInfo *info);
+
+int32_t canvas_native_webgl_shader_precision_format_get_range_min(const struct WebGLShaderPrecisionFormat *shader);
+
+int32_t canvas_native_webgl_shader_precision_format_get_range_max(const struct WebGLShaderPrecisionFormat *shader);
+
+int32_t canvas_native_webgl_shader_precision_format_get_precision(const struct WebGLShaderPrecisionFormat *shader);
+
+bool canvas_native_webgl_context_attribute_get_get_alpha(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_attribute_get_get_antialias(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_attribute_get_get_depth(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_attribute_get_get_fail_if_major_performance_caveat(const struct ContextAttributes *attr);
+
+const char *canvas_native_webgl_context_attribute_get_get_power_preference(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_attribute_get_get_premultiplied_alpha(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_attribute_get_get_preserve_drawing_buffer(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_attribute_get_get_stencil(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_attribute_get_get_desynchronized(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_attribute_get_get_xr_compatible(const struct ContextAttributes *attr);
+
+bool canvas_native_webgl_context_extension_is_none(const struct WebGLExtension *extension);
+
+enum WebGLExtensionType canvas_native_webgl_context_extension_get_type(const struct WebGLExtension *extension);
+
+struct EXT_disjoint_timer_query *canvas_native_webgl_context_extension_to_ext_disjoint_timer_query(struct WebGLExtension *extension);
+
+struct ANGLE_instanced_arrays *canvas_native_webgl_context_extension_to_angle_instanced_arrays(struct WebGLExtension *extension);
+
+struct WEBGL_lose_context *canvas_native_webgl_context_extension_to_lose_context(struct WebGLExtension *extension);
+
+struct WEBGL_draw_buffers *canvas_native_webgl_context_extension_to_draw_buffers(struct WebGLExtension *extension);
+
+struct OES_vertex_array_object *canvas_native_webgl_context_extension_to_oes_vertex_array_object(struct WebGLExtension *extension);
+
+enum WebGLResultType canvas_native_webgl_result_get_type(const struct WebGLResult *result);
+
+bool canvas_native_webgl_result_get_bool(const struct WebGLResult *result);
+
+struct I32Buffer *canvas_native_webgl_result_get_i32_array(const struct WebGLResult *result);
+
+struct U32Buffer *canvas_native_webgl_result_get_u32_array(const struct WebGLResult *result);
+
+struct F32Buffer *canvas_native_webgl_result_get_f32_array(const struct WebGLResult *result);
+
+struct U8Buffer *canvas_native_webgl_result_get_bool_array(const struct WebGLResult *result);
+
+uint32_t canvas_native_webgl_result_get_u32(const struct WebGLResult *result);
+
+int32_t canvas_native_webgl_result_get_i32(const struct WebGLResult *result);
+
+float canvas_native_webgl_result_get_f32(const struct WebGLResult *result);
+
+const char *canvas_native_webgl_result_get_string(const struct WebGLResult *result);
+
+bool canvas_native_webgl_result_get_is_none(const struct WebGLResult *result);
+
+int32_t canvas_native_webgl_state_get_unpack_colorspace_conversion_webgl(struct WebGLState *state);
+
+bool canvas_native_webgl_state_get_flip_y(struct WebGLState *state);
+
+bool canvas_native_webgl_state_get_premultiplied_alpha(struct WebGLState *state);
+
+int32_t canvas_native_webgl_state_get_drawing_buffer_width(struct WebGLState *state);
+
+int32_t canvas_native_webgl_state_get_drawing_buffer_height(struct WebGLState *state);
+
+uint32_t canvas_native_webgl_ext_disjoint_timer_query_create_query_ext(const struct EXT_disjoint_timer_query *query);
+
+void canvas_native_webgl_ext_disjoint_timer_query_delete_query_ext(uint32_t value,
+                                                                   const struct EXT_disjoint_timer_query *query);
+
+bool canvas_native_webgl_ext_disjoint_timer_query_is_query_ext(uint32_t value,
+                                                               const struct EXT_disjoint_timer_query *query);
+
+void canvas_native_webgl_ext_disjoint_timer_query_begin_query_ext(uint32_t target,
+                                                                  uint32_t value,
+                                                                  const struct EXT_disjoint_timer_query *query);
+
+void canvas_native_webgl_ext_disjoint_timer_query_end_query_ext(uint32_t target,
+                                                                const struct EXT_disjoint_timer_query *query);
+
+void canvas_native_webgl_ext_disjoint_timer_query_query_counter_ext(uint32_t value,
+                                                                    uint32_t target,
+                                                                    const struct EXT_disjoint_timer_query *query);
+
+int32_t canvas_native_webgl_ext_disjoint_timer_query_get_query_ext(uint32_t target,
+                                                                   uint32_t pname,
+                                                                   const struct EXT_disjoint_timer_query *query);
+
+struct WebGLResult *canvas_native_webgl_ext_disjoint_timer_query_get_query_object_ext(uint32_t target,
+                                                                                      uint32_t pname,
+                                                                                      const struct EXT_disjoint_timer_query *query);
+
+void canvas_native_webgl_angle_instanced_arrays_draw_arrays_instanced_angle(uint32_t mode,
+                                                                            int32_t first,
+                                                                            int32_t count,
+                                                                            int32_t primcount,
+                                                                            const struct ANGLE_instanced_arrays *arrays);
+
+void canvas_native_webgl_angle_instanced_arrays_draw_elements_instanced_angle(uint32_t mode,
+                                                                              int32_t count,
+                                                                              uint32_t type_,
+                                                                              int32_t offset,
+                                                                              int32_t primcount,
+                                                                              const struct ANGLE_instanced_arrays *arrays);
+
+void canvas_native_webgl_angle_instanced_arrays_vertex_attrib_divisor_angle(uint32_t index,
+                                                                            uint32_t divisor,
+                                                                            const struct ANGLE_instanced_arrays *arrays);
+
+void canvas_native_webgl_lose_context_lose_context(const struct WEBGL_lose_context *context);
+
+void canvas_native_webgl_lose_context_restore_context(const struct WEBGL_lose_context *context);
+
+void canvas_native_webgl_draw_buffers_draw_buffers_webgl(const uint32_t *buffers,
+                                                         uintptr_t size,
+                                                         const struct WEBGL_draw_buffers *context);
+
+uint32_t canvas_native_webgl_oes_vertex_array_object_create_vertex_array_oes(const struct OES_vertex_array_object *object);
+
+void canvas_native_webgl_oes_vertex_array_object_delete_vertex_array_oes(uint32_t array_object,
+                                                                         const struct OES_vertex_array_object *object);
+
+bool canvas_native_webgl_oes_vertex_array_object_is_vertex_array_oes(uint32_t array_object,
+                                                                     const struct OES_vertex_array_object *object);
+
+void canvas_native_webgl_oes_vertex_array_object_bind_vertex_array_oes(uint32_t array_object,
+                                                                       const struct OES_vertex_array_object *object);
+
+struct WebGLState *canvas_native_webgl_create(int64_t gl_context,
+                                              const char *version,
+                                              bool alpha,
+                                              bool antialias,
+                                              bool depth,
+                                              bool fail_if_major_performance_caveat,
+                                              const char *power_preference,
+                                              bool premultiplied_alpha,
+                                              bool preserve_drawing_buffer,
+                                              bool stencil,
+                                              bool desynchronized,
+                                              bool xr_compatible);
+
+struct WebGLState *canvas_native_webgl_create_no_window(int32_t width,
+                                                        int32_t height,
+                                                        const char *version,
+                                                        bool alpha,
+                                                        bool antialias,
+                                                        bool depth,
+                                                        bool fail_if_major_performance_caveat,
+                                                        const char *power_preference,
+                                                        bool premultiplied_alpha,
+                                                        bool preserve_drawing_buffer,
+                                                        bool stencil,
+                                                        bool desynchronized,
+                                                        bool xr_compatible,
+                                                        bool is_canvas);
+
+void canvas_native_webgl_active_texture(uint32_t texture, struct WebGLState *state);
+
+void canvas_native_webgl_attach_shader(uint32_t program, uint32_t shader, struct WebGLState *state);
+
+void canvas_native_webgl_bind_attrib_location(uint32_t program,
+                                              uint32_t index,
+                                              const char *name,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl_bind_buffer(uint32_t target, uint32_t buffer, struct WebGLState *state);
+
+void canvas_native_webgl_bind_frame_buffer(uint32_t target,
+                                           uint32_t framebuffer,
+                                           struct WebGLState *state);
+
+void canvas_native_webgl_bind_render_buffer(uint32_t target,
+                                            uint32_t renderbuffer,
+                                            struct WebGLState *state);
+
+void canvas_native_webgl_bind_texture(uint32_t target, uint32_t texture, struct WebGLState *state);
+
+void canvas_native_webgl_blend_color(float red,
+                                     float green,
+                                     float blue,
+                                     float alpha,
+                                     struct WebGLState *state);
+
+void canvas_native_webgl_blend_equation_separate(uint32_t mode_rgb,
+                                                 uint32_t mode_alpha,
+                                                 struct WebGLState *state);
+
+void canvas_native_webgl_blend_equation(uint32_t mode, struct WebGLState *state);
+
+void canvas_native_webgl_blend_func_separate(uint32_t src_rgb,
+                                             uint32_t dst_rgb,
+                                             uint32_t src_alpha,
+                                             uint32_t dst_alpha,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl_blend_func(uint32_t sfactor, uint32_t dfactor, struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data(uint32_t target,
+                                     const uint8_t *src_data,
+                                     uintptr_t size,
+                                     uint32_t usage,
+                                     struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data_i8(uint32_t target,
+                                        const int8_t *src_data,
+                                        uintptr_t size,
+                                        uint32_t usage,
+                                        struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data_u16(uint32_t target,
+                                         const uint16_t *src_data,
+                                         uintptr_t size,
+                                         uint32_t usage,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data_i16(uint32_t target,
+                                         const int16_t *src_data,
+                                         uintptr_t size,
+                                         uint32_t usage,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data_u32(uint32_t target,
+                                         const uint32_t *src_data,
+                                         uintptr_t size,
+                                         uint32_t usage,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data_i32(uint32_t target,
+                                         const int32_t *src_data,
+                                         uintptr_t size,
+                                         uint32_t usage,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data_f32(uint32_t target,
+                                         const float *src_data,
+                                         uintptr_t size,
+                                         uint32_t usage,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data_f64(uint32_t target,
+                                         const double *src_data,
+                                         uintptr_t size,
+                                         uint32_t usage,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_buffer_data_none(uint32_t target,
+                                          intptr_t size,
+                                          uint32_t usage,
+                                          struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data(uint32_t target,
+                                         intptr_t offset,
+                                         const uint8_t *src_data,
+                                         uintptr_t size,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data_i8(uint32_t target,
+                                            intptr_t offset,
+                                            const int8_t *src_data,
+                                            uintptr_t size,
+                                            struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data_i16(uint32_t target,
+                                             intptr_t offset,
+                                             const int16_t *src_data,
+                                             uintptr_t size,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data_u16(uint32_t target,
+                                             intptr_t offset,
+                                             const uint16_t *src_data,
+                                             uintptr_t size,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data_i32(uint32_t target,
+                                             intptr_t offset,
+                                             const int32_t *src_data,
+                                             uintptr_t size,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data_u32(uint32_t target,
+                                             intptr_t offset,
+                                             const uint32_t *src_data,
+                                             uintptr_t size,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data_f32(uint32_t target,
+                                             intptr_t offset,
+                                             const float *src_data,
+                                             uintptr_t size,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data_f64(uint32_t target,
+                                             intptr_t offset,
+                                             const double *src_data,
+                                             uintptr_t size,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl_buffer_sub_data_none(uint32_t target,
+                                              intptr_t offset,
+                                              struct WebGLState *state);
+
+uint32_t canvas_native_webgl_check_frame_buffer_status(uint32_t target, struct WebGLState *state);
+
+void canvas_native_webgl_clear(uint32_t mask, struct WebGLState *state);
+
+void canvas_native_webgl_clear_color(float red,
+                                     float green,
+                                     float blue,
+                                     float alpha,
+                                     struct WebGLState *state);
+
+void canvas_native_webgl_clear_depth(float depth, struct WebGLState *state);
+
+void canvas_native_webgl_clear_stencil(int32_t stencil, struct WebGLState *state);
+
+void canvas_native_webgl_color_mask(bool red,
+                                    bool green,
+                                    bool blue,
                                     bool alpha,
-                                    bool antialias,
-                                    bool depth,
-                                    bool fail_if_major_performance_caveat,
-                                    const char *power_preference,
-                                    bool premultiplied_alpha,
-                                    bool preserve_drawing_buffer,
-                                    bool stencil,
-                                    bool desynchronized,
-                                    bool xr_compatible,
-                                    int32_t version,
-                                    bool is_canvas);
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_commit(struct WebGLState*);
+
+void canvas_native_webgl_compile_shader(uint32_t shader, struct WebGLState *state);
+
+void canvas_native_webgl_compressed_tex_image2d(uint32_t target,
+                                                int32_t level,
+                                                uint32_t internalformat,
+                                                int32_t width,
+                                                int32_t height,
+                                                int32_t border,
+                                                const uint8_t *pixels,
+                                                uintptr_t size,
+                                                struct WebGLState *state);
+
+void canvas_native_webgl_compressed_tex_image2d_none(uint32_t target,
+                                                     int32_t level,
+                                                     uint32_t internalformat,
+                                                     int32_t width,
+                                                     int32_t height,
+                                                     int32_t border,
+                                                     struct WebGLState *state);
+
+void canvas_native_webgl_compressed_tex_sub_image2d(uint32_t target,
+                                                    int32_t level,
+                                                    int32_t xoffset,
+                                                    int32_t yoffset,
+                                                    int32_t width,
+                                                    int32_t height,
+                                                    uint32_t format,
+                                                    const uint8_t *pixels,
+                                                    uintptr_t size,
+                                                    struct WebGLState *state);
+
+void canvas_native_webgl_copy_tex_image2d(uint32_t target,
+                                          int32_t level,
+                                          uint32_t internalformat,
+                                          int32_t x,
+                                          int32_t y,
+                                          int32_t width,
+                                          int32_t height,
+                                          int32_t border,
+                                          struct WebGLState *state);
+
+void canvas_native_webgl_copy_tex_sub_image2d(uint32_t target,
+                                              int32_t level,
+                                              int32_t xoffset,
+                                              int32_t yoffset,
+                                              int32_t x,
+                                              int32_t y,
+                                              int32_t width,
+                                              int32_t height,
+                                              struct WebGLState *state);
+
+uint32_t canvas_native_webgl_create_buffer(struct WebGLState *state);
+
+uint32_t canvas_native_webgl_create_framebuffer(struct WebGLState *state);
+
+uint32_t canvas_native_webgl_create_program(struct WebGLState *state);
+
+uint32_t canvas_native_webgl_create_renderbuffer(struct WebGLState *state);
+
+uint32_t canvas_native_webgl_create_shader(uint32_t shader_type, struct WebGLState *state);
+
+uint32_t canvas_native_webgl_create_texture(struct WebGLState *state);
+
+void canvas_native_webgl_cull_face(uint32_t mode, struct WebGLState *state);
+
+void canvas_native_webgl_delete_buffer(uint32_t buffer, struct WebGLState *state);
+
+void canvas_native_webgl_delete_framebuffer(uint32_t frame_buffer, struct WebGLState *state);
+
+void canvas_native_webgl_delete_program(uint32_t program, struct WebGLState *state);
+
+void canvas_native_webgl_delete_renderbuffer(uint32_t render_buffer, struct WebGLState *state);
+
+void canvas_native_webgl_delete_shader(uint32_t shader, struct WebGLState *state);
+
+void canvas_native_webgl_delete_texture(uint32_t texture, struct WebGLState *state);
+
+void canvas_native_webgl_depth_func(uint32_t func, struct WebGLState *state);
+
+void canvas_native_webgl_depth_mask(bool flag, struct WebGLState *state);
+
+void canvas_native_webgl_depth_range(float z_near, float z_far, struct WebGLState *state);
+
+void canvas_native_webgl_detach_shader(uint32_t program, uint32_t shader, struct WebGLState *state);
+
+void canvas_native_webgl_disable(uint32_t cap, struct WebGLState *state);
+
+void canvas_native_webgl_disable_vertex_attrib_array(uint32_t index, struct WebGLState *state);
 
-bool canvas_native_ios_flush_gl(int64_t context);
+void canvas_native_webgl_draw_arrays(uint32_t mode,
+                                     int32_t first,
+                                     int32_t count,
+                                     struct WebGLState *state);
 
-void canvas_native_ios_flush_2d_context(int64_t context);
+void canvas_native_webgl_draw_elements(uint32_t mode,
+                                       int32_t count,
+                                       uint32_t element_type,
+                                       intptr_t offset,
+                                       struct WebGLState *state);
 
-void canvas_native_resize_context_2d(int64_t context, float width, float height);
+void canvas_native_webgl_enable(uint32_t cap, struct WebGLState *state);
 
-int64_t canvas_native_create_2d_context(int64_t context,
+void canvas_native_webgl_enable_vertex_attrib_array(uint32_t index, struct WebGLState *state);
+
+void canvas_native_webgl_finish(struct WebGLState *state);
+
+void canvas_native_webgl_flush(struct WebGLState *state);
+
+void canvas_native_webgl_framebuffer_renderbuffer(uint32_t target,
+                                                  uint32_t attachment,
+                                                  uint32_t renderbuffertarget,
+                                                  uint32_t renderbuffer,
+                                                  struct WebGLState *state);
+
+void canvas_native_webgl_framebuffer_texture2d(uint32_t target,
+                                               uint32_t attachment,
+                                               uint32_t textarget,
+                                               uint32_t texture,
+                                               int32_t level,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl_front_face(uint32_t mode, struct WebGLState *state);
+
+void canvas_native_webgl_generate_mipmap(uint32_t target, struct WebGLState *state);
+
+struct WebGLActiveInfo *canvas_native_webgl_get_active_attrib(uint32_t program,
+                                                              uint32_t index,
+                                                              struct WebGLState *state);
+
+struct WebGLActiveInfo *canvas_native_webgl_get_active_uniform(uint32_t program,
+                                                               uint32_t index,
+                                                               struct WebGLState *state);
+
+struct U32Buffer *canvas_native_webgl_get_attached_shaders(uint32_t program,
+                                                           struct WebGLState *state);
+
+int32_t canvas_native_webgl_get_attrib_location(uint32_t program,
+                                                const char *name,
+                                                struct WebGLState *state);
+
+int32_t canvas_native_webgl_get_buffer_parameter(uint32_t target,
+                                                 uint32_t pname,
+                                                 struct WebGLState *state);
+
+struct ContextAttributes *canvas_native_webgl_get_context_attributes(struct WebGLState *state);
+
+uint32_t canvas_native_webgl_get_error(struct WebGLState *state);
+
+struct WebGLExtension *canvas_native_webgl_get_extension(const char *name,
+                                                         struct WebGLState *state);
+
+struct WebGLFramebufferAttachmentParameter *canvas_native_webgl_get_framebuffer_attachment_parameter(uint32_t target,
+                                                                                                     uint32_t attachment,
+                                                                                                     uint32_t pname,
+                                                                                                     struct WebGLState *state);
+
+bool canvas_native_webgl_framebuffer_attachment_parameter_get_is_texture(const struct WebGLFramebufferAttachmentParameter *param);
+
+bool canvas_native_webgl_framebuffer_attachment_parameter_get_is_renderbuffer(const struct WebGLFramebufferAttachmentParameter *param);
+
+int32_t canvas_native_webgl_framebuffer_attachment_parameter_get_value(const struct WebGLFramebufferAttachmentParameter *param);
+
+struct WebGLResult *canvas_native_webgl_get_parameter(uint32_t pname, struct WebGLState *state);
+
+const char *canvas_native_webgl_get_program_info_log(uint32_t program, struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl_get_program_parameter(uint32_t program,
+                                                              uint32_t pname,
+                                                              struct WebGLState *state);
+
+int32_t canvas_native_webgl_get_renderbuffer_parameter(uint32_t target,
+                                                       uint32_t pname,
+                                                       struct WebGLState *state);
+
+const char *canvas_native_webgl_get_shader_info_log(uint32_t shader, struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl_get_shader_parameter(uint32_t shader,
+                                                             uint32_t pname,
+                                                             struct WebGLState *state);
+
+struct WebGLShaderPrecisionFormat *canvas_native_webgl_get_shader_precision_format(uint32_t shader_type,
+                                                                                   uint32_t precision_type,
+                                                                                   struct WebGLState *state);
+
+const char *canvas_native_webgl_get_shader_source(uint32_t shader, struct WebGLState *state);
+
+struct StringBuffer *canvas_native_webgl_get_supported_extensions(struct WebGLState *state);
+
+const char *canvas_native_webgl_get_supported_extensions_to_string(struct WebGLState *state);
+
+int32_t canvas_native_webgl_get_tex_parameter(uint32_t target,
+                                              uint32_t pname,
+                                              struct WebGLState *state);
+
+int32_t canvas_native_webgl_get_uniform_location(uint32_t program,
+                                                 const char *name,
+                                                 struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl_get_uniform(uint32_t program,
+                                                    int32_t location,
+                                                    struct WebGLState *state);
+
+uintptr_t canvas_native_webgl_get_vertex_attrib_offset(uint32_t index,
+                                                       uint32_t pname,
+                                                       struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl_get_vertex_attrib(uint32_t index,
+                                                          uint32_t pname,
+                                                          struct WebGLState *state);
+
+bool canvas_native_webgl_get_is_context_lost(struct WebGLState*);
+
+void canvas_native_webgl_hint(uint32_t target, uint32_t mode, struct WebGLState *state);
+
+bool canvas_native_webgl_is_buffer(uint32_t buffer, struct WebGLState *state);
+
+bool canvas_native_webgl_is_enabled(uint32_t cap, struct WebGLState *state);
+
+bool canvas_native_webgl_is_framebuffer(uint32_t framebuffer, struct WebGLState *state);
+
+bool canvas_native_webgl_is_program(uint32_t program, struct WebGLState *state);
+
+bool canvas_native_webgl_is_renderbuffer(uint32_t renderbuffer, struct WebGLState *state);
+
+bool canvas_native_webgl_is_shader(uint32_t shader, struct WebGLState *state);
+
+bool canvas_native_webgl_is_texture(uint32_t texture, struct WebGLState *state);
+
+void canvas_native_webgl_line_width(float width, struct WebGLState *state);
+
+void canvas_native_webgl_link_program(uint32_t program, struct WebGLState *state);
+
+void canvas_native_webgl_pixel_storei(uint32_t pname, int32_t param, struct WebGLState *state);
+
+void canvas_native_webgl_polygon_offset(float factor, float units, struct WebGLState *state);
+
+void canvas_native_webgl_read_pixels_u8(int32_t x,
+                                        int32_t y,
                                         int32_t width,
                                         int32_t height,
-                                        bool alpha,
-                                        float density,
-                                        int32_t samples,
-                                        int32_t font_color,
-                                        float ppi,
-                                        int32_t direction);
+                                        uint32_t format,
+                                        uint32_t pixel_type,
+                                        uint8_t *pixels,
+                                        uintptr_t size,
+                                        struct WebGLState *state);
+
+void canvas_native_webgl_read_pixels_u16(int32_t x,
+                                         int32_t y,
+                                         int32_t width,
+                                         int32_t height,
+                                         uint32_t format,
+                                         uint32_t pixel_type,
+                                         uint16_t *pixels,
+                                         uintptr_t size,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_read_pixels_f32(int32_t x,
+                                         int32_t y,
+                                         int32_t width,
+                                         int32_t height,
+                                         uint32_t format,
+                                         uint32_t pixel_type,
+                                         float *pixels,
+                                         uintptr_t size,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_renderbuffer_storage(uint32_t target,
+                                              uint32_t internal_format,
+                                              int32_t width,
+                                              int32_t height,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl_sample_coverage(float value, bool invert, struct WebGLState *state);
+
+void canvas_native_webgl_scissor(int32_t x,
+                                 int32_t y,
+                                 int32_t width,
+                                 int32_t height,
+                                 struct WebGLState *state);
+
+void canvas_native_webgl_shader_source(uint32_t shader,
+                                       const char *source,
+                                       struct WebGLState *state);
+
+void canvas_native_webgl_stencil_func(uint32_t func,
+                                      int32_t reference,
+                                      uint32_t mask,
+                                      struct WebGLState *state);
+
+void canvas_native_webgl_stencil_func_separate(uint32_t face,
+                                               uint32_t func,
+                                               int32_t reference,
+                                               uint32_t mask,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl_stencil_mask(uint32_t mask, struct WebGLState *state);
+
+void canvas_native_webgl_stencil_mask_separate(uint32_t face,
+                                               uint32_t mask,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl_stencil_op(uint32_t fail,
+                                    uint32_t zfail,
+                                    uint32_t zpass,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_stencil_op_separate(uint32_t face,
+                                             uint32_t fail,
+                                             uint32_t zfail,
+                                             uint32_t zpass,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl_tex_image2d_image_none(int32_t target,
+                                                int32_t level,
+                                                int32_t internalformat,
+                                                int32_t format,
+                                                int32_t image_type,
+                                                struct WebGLState *state);
+
+void canvas_native_webgl_tex_image2d_canvas2d(int32_t target,
+                                              int32_t level,
+                                              int32_t internalformat,
+                                              int32_t format,
+                                              int32_t image_type,
+                                              struct CanvasRenderingContext2D *canvas,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl_tex_image2d_webgl(int32_t target,
+                                           int32_t level,
+                                           int32_t _internalformat,
+                                           int32_t _format,
+                                           int32_t _image_type,
+                                           struct WebGLState *webgl,
+                                           struct WebGLState *state);
+
+void canvas_native_webgl_tex_image2d(int32_t target,
+                                     int32_t level,
+                                     int32_t internalformat,
+                                     int32_t width,
+                                     int32_t height,
+                                     int32_t border,
+                                     int32_t format,
+                                     int32_t image_type,
+                                     const uint8_t *buf,
+                                     uintptr_t size,
+                                     struct WebGLState *state);
+
+void canvas_native_webgl_tex_image2d_none(int32_t target,
+                                          int32_t level,
+                                          int32_t internalformat,
+                                          int32_t width,
+                                          int32_t height,
+                                          int32_t border,
+                                          int32_t format,
+                                          int32_t image_type,
+                                          struct WebGLState *state);
+
+void canvas_native_webgl_tex_image2d_image_asset(int32_t target,
+                                                 int32_t level,
+                                                 int32_t internalformat,
+                                                 int32_t format,
+                                                 int32_t image_type,
+                                                 struct ImageAsset *image_asset,
+                                                 struct WebGLState *state);
+
+void canvas_native_webgl_tex_parameterf(uint32_t target,
+                                        uint32_t pname,
+                                        float param,
+                                        struct WebGLState *state);
+
+void canvas_native_webgl_tex_parameteri(uint32_t target,
+                                        uint32_t pname,
+                                        int32_t param,
+                                        struct WebGLState *state);
+
+void canvas_native_webgl_tex_sub_image2d_asset(uint32_t target,
+                                               int32_t level,
+                                               int32_t xoffset,
+                                               int32_t yoffset,
+                                               uint32_t format,
+                                               int32_t image_type,
+                                               struct ImageAsset *asset,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl_tex_sub_image2d_canvas2d(uint32_t target,
+                                                  int32_t level,
+                                                  int32_t xoffset,
+                                                  int32_t yoffset,
+                                                  uint32_t format,
+                                                  int32_t image_type,
+                                                  struct CanvasRenderingContext2D *canvas,
+                                                  struct WebGLState *state);
+
+void canvas_native_webgl_tex_sub_image2d_webgl(uint32_t target,
+                                               int32_t level,
+                                               int32_t xoffset,
+                                               int32_t yoffset,
+                                               uint32_t _format,
+                                               int32_t _image_type,
+                                               struct WebGLState *webgl,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl_tex_sub_image2d(uint32_t target,
+                                         int32_t level,
+                                         int32_t xoffset,
+                                         int32_t yoffset,
+                                         int32_t width,
+                                         int32_t height,
+                                         uint32_t format,
+                                         int32_t image_type,
+                                         const uint8_t *buf,
+                                         uintptr_t size,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_uniform1f(int32_t location, float v0, struct WebGLState *state);
+
+void canvas_native_webgl_uniform1fv(int32_t location,
+                                    const float *value,
+                                    uintptr_t size,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_uniform1i(int32_t location, int32_t v0, struct WebGLState *state);
+
+void canvas_native_webgl_uniform1iv(int32_t location,
+                                    const int32_t *value,
+                                    uintptr_t size,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_uniform2f(int32_t location, float v0, float v1, struct WebGLState *state);
+
+void canvas_native_webgl_uniform2fv(int32_t location,
+                                    const float *value,
+                                    uintptr_t size,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_uniform2i(int32_t location,
+                                   int32_t v0,
+                                   int32_t v1,
+                                   struct WebGLState *state);
+
+void canvas_native_webgl_uniform2iv(int32_t location,
+                                    const int32_t *value,
+                                    uintptr_t size,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_uniform3f(int32_t location,
+                                   float v0,
+                                   float v1,
+                                   float v2,
+                                   struct WebGLState *state);
+
+void canvas_native_webgl_uniform3fv(int32_t location,
+                                    const float *value,
+                                    uintptr_t size,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_uniform3i(int32_t location,
+                                   int32_t v0,
+                                   int32_t v1,
+                                   int32_t v2,
+                                   struct WebGLState *state);
+
+void canvas_native_webgl_uniform3iv(int32_t location,
+                                    const int32_t *value,
+                                    uintptr_t size,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_uniform4f(int32_t location,
+                                   float v0,
+                                   float v1,
+                                   float v2,
+                                   float v3,
+                                   struct WebGLState *state);
+
+void canvas_native_webgl_uniform4fv(int32_t location,
+                                    const float *value,
+                                    uintptr_t size,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_uniform4i(int32_t location,
+                                   int32_t v0,
+                                   int32_t v1,
+                                   int32_t v2,
+                                   int32_t v3,
+                                   struct WebGLState *state);
+
+void canvas_native_webgl_uniform4iv(int32_t location,
+                                    const int32_t *value,
+                                    uintptr_t size,
+                                    struct WebGLState *state);
+
+void canvas_native_webgl_uniform_matrix2fv(int32_t location,
+                                           bool transpose,
+                                           const float *value,
+                                           uintptr_t size,
+                                           struct WebGLState *state);
+
+void canvas_native_webgl_uniform_matrix3fv(int32_t location,
+                                           bool transpose,
+                                           const float *value,
+                                           uintptr_t size,
+                                           struct WebGLState *state);
+
+void canvas_native_webgl_uniform_matrix4fv(int32_t location,
+                                           bool transpose,
+                                           const float *value,
+                                           uintptr_t size,
+                                           struct WebGLState *state);
+
+void canvas_native_webgl_use_program(uint32_t program, struct WebGLState *state);
+
+void canvas_native_webgl_validate_program(uint32_t program, struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib1f(uint32_t index, float v0, struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib1fv(uint32_t index,
+                                          const float *value,
+                                          uintptr_t size,
+                                          struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib2f(uint32_t index,
+                                         float v0,
+                                         float v1,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib2fv(uint32_t index,
+                                          const float *value,
+                                          uintptr_t size,
+                                          struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib3f(uint32_t index,
+                                         float v0,
+                                         float v1,
+                                         float v2,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib3fv(uint32_t index,
+                                          const float *value,
+                                          uintptr_t size,
+                                          struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib4f(uint32_t index,
+                                         float v0,
+                                         float v1,
+                                         float v2,
+                                         float v3,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib4fv(uint32_t index,
+                                          const float *value,
+                                          uintptr_t size,
+                                          struct WebGLState *state);
+
+void canvas_native_webgl_vertex_attrib_pointer(uint32_t index,
+                                               int32_t size,
+                                               uint32_t d_type,
+                                               bool normalized,
+                                               int32_t stride,
+                                               intptr_t offset,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl_viewport(int32_t x,
+                                  int32_t y,
+                                  int32_t width,
+                                  int32_t height,
+                                  struct WebGLState *state);
+
+intptr_t canvas_native_webgl2_indexed_parameter_get_value(const struct WebGLIndexedParameter *param);
+
+intptr_t canvas_native_webgl2_indexed_parameter_get_buffer_value(const struct WebGLIndexedParameter *param);
+
+bool canvas_native_webgl2_indexed_parameter_get_is_buffer(const struct WebGLIndexedParameter *param);
+
+void canvas_native_webgl2_begin_query(uint32_t target, uint32_t id, struct WebGLState *state);
+
+void canvas_native_webgl2_begin_transform_feedback(uint32_t primitive_mode,
+                                                   struct WebGLState *state);
+
+void canvas_native_webgl2_bind_buffer_base(uint32_t target,
+                                           uint32_t index,
+                                           uint32_t buffer,
+                                           struct WebGLState *state);
+
+void canvas_native_webgl2_bind_buffer_range(uint32_t target,
+                                            uint32_t index,
+                                            uint32_t buffer,
+                                            intptr_t offset,
+                                            intptr_t size,
+                                            struct WebGLState *state);
+
+void canvas_native_webgl2_bind_sampler(uint32_t unit, uint32_t sampler, struct WebGLState *state);
+
+void canvas_native_webgl2_bind_transform_feedback(uint32_t target,
+                                                  uint32_t transform_feedback,
+                                                  struct WebGLState *state);
+
+void canvas_native_webgl2_bind_vertex_array(uint32_t vertex_array, struct WebGLState *state);
+
+void canvas_native_webgl2_blit_framebuffer(int32_t src_x0,
+                                           int32_t src_y0,
+                                           int32_t src_x1,
+                                           int32_t src_y1,
+                                           int32_t dst_x0,
+                                           int32_t dst_y0,
+                                           int32_t dst_x1,
+                                           int32_t dst_y1,
+                                           uint32_t mask,
+                                           uint32_t filter,
+                                           struct WebGLState *state);
+
+void canvas_native_webgl2_clear_bufferfi(uint32_t buffer,
+                                         int32_t drawbuffer,
+                                         float depth,
+                                         int32_t stencil,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl2_clear_bufferfv(uint32_t buffer,
+                                         int32_t drawbuffer,
+                                         const float *values,
+                                         uintptr_t size,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl2_clear_bufferiv(uint32_t buffer,
+                                         int32_t drawbuffer,
+                                         const int32_t *values,
+                                         uintptr_t size,
+                                         struct WebGLState *state);
+
+void canvas_native_webgl2_clear_bufferuiv(uint32_t buffer,
+                                          int32_t drawbuffer,
+                                          const uint32_t *values,
+                                          uintptr_t size,
+                                          struct WebGLState *state);
+
+uint32_t canvas_native_webgl2_client_wait_sync(const struct WebGLSync *sync,
+                                               uint32_t flags,
+                                               intptr_t timeout,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl2_compressed_tex_sub_image3d_none(uint32_t target,
+                                                          int32_t level,
+                                                          int32_t xoffset,
+                                                          int32_t yoffset,
+                                                          int32_t zoffset,
+                                                          int32_t width,
+                                                          int32_t height,
+                                                          int32_t depth,
+                                                          uint32_t format,
+                                                          int32_t image_size,
+                                                          int32_t offset,
+                                                          struct WebGLState *state);
+
+void canvas_native_webgl2_compressed_tex_sub_image3d(uint32_t target,
+                                                     int32_t level,
+                                                     int32_t xoffset,
+                                                     int32_t yoffset,
+                                                     int32_t zoffset,
+                                                     int32_t width,
+                                                     int32_t height,
+                                                     int32_t depth,
+                                                     uint32_t format,
+                                                     const uint8_t *src,
+                                                     uintptr_t size,
+                                                     uintptr_t src_offset,
+                                                     uintptr_t src_length_override,
+                                                     struct WebGLState *state);
+
+void canvas_native_webgl2_copy_buffer_sub_data(uint32_t read_target,
+                                               uint32_t write_target,
+                                               intptr_t read_offset,
+                                               intptr_t write_offset,
+                                               intptr_t size,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl2_copy_tex_sub_image3d(uint32_t target,
+                                               int32_t level,
+                                               int32_t xoffset,
+                                               int32_t yoffset,
+                                               int32_t zoffset,
+                                               int32_t x,
+                                               int32_t y,
+                                               int32_t width,
+                                               int32_t height,
+                                               struct WebGLState *state);
+
+uint32_t canvas_native_webgl2_create_query(struct WebGLState *state);
+
+uint32_t canvas_native_webgl2_create_sampler(struct WebGLState *state);
+
+uint32_t canvas_native_webgl2_create_transform_feedback(struct WebGLState *state);
+
+uint32_t canvas_native_webgl2_create_vertex_array(struct WebGLState *state);
+
+void canvas_native_webgl2_delete_query_with_query(uint32_t id, struct WebGLState *state);
+
+void canvas_native_webgl2_delete_sampler_with_sampler(uint32_t sampler, struct WebGLState *state);
 
-void canvas_native_update_gl_surface(int64_t view, int32_t width, int32_t height, int64_t context);
+void canvas_native_webgl2_delete_sync_with_sync(const struct WebGLSync *sync,
+                                                struct WebGLState *state);
 
-void canvas_native_release_ios_gl(int64_t context);
+void canvas_native_webgl2_delete_transform_feedback(uint32_t transform_feedback,
+                                                    struct WebGLState *state);
 
-int64_t canvas_native_get_gl_pointer(int64_t gl_context);
+void canvas_native_webgl2_delete_vertex_array_with_vertex_array(uint32_t vertex_array,
+                                                                struct WebGLState *state);
 
-void canvas_native_release_gl_pointer(int64_t gl_context);
+void canvas_native_webgl2_draw_arrays_instanced(uint32_t mode,
+                                                int32_t first,
+                                                int32_t count,
+                                                int32_t instance_count,
+                                                struct WebGLState *state);
 
-void canvas_native_context_2d_test(int64_t context);
+void canvas_native_webgl2_draw_buffers(const uint32_t *buffers,
+                                       uintptr_t size,
+                                       struct WebGLState *state);
 
-char *canvas_native_context_2d_test_to_data_url(int64_t context);
+void canvas_native_webgl2_draw_elements_instanced(uint32_t mode,
+                                                  int32_t count,
+                                                  uint32_t type_,
+                                                  intptr_t offset,
+                                                  int32_t instance_count,
+                                                  struct WebGLState *state);
 
-void canvas_native_context_2d_destroy_string(char *string);
+void canvas_native_webgl2_draw_range_elements(uint32_t mode,
+                                              uint32_t start,
+                                              uint32_t end,
+                                              int32_t count,
+                                              uint32_t type_,
+                                              intptr_t offset,
+                                              struct WebGLState *state);
 
-bool canvas_native_imageasset_load_from_bytes(int64_t asset, uint8_t *bytes, uintptr_t size);
+void canvas_native_webgl2_end_query(uint32_t target, struct WebGLState *state);
 
-int64_t canvas_native_context_create_pattern(int64_t context,
+void canvas_native_webgl2_end_transform_feedback(struct WebGLState *state);
+
+struct WebGLSync *canvas_native_webgl2_fence_sync(uint32_t condition,
+                                                  uint32_t flags,
+                                                  struct WebGLState *state);
+
+void canvas_native_webgl2_framebuffer_texture_layer(uint32_t target,
+                                                    uint32_t attachment,
+                                                    uint32_t texture,
+                                                    int32_t level,
+                                                    int32_t layer,
+                                                    struct WebGLState *state);
+
+const char *canvas_native_webgl2_get_active_uniform_block_name(uint32_t program,
+                                                               uint32_t uniform_block_index,
+                                                               struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl2_get_active_uniform_block_parameter(uint32_t program,
+                                                                            uint32_t uniform_block_index,
+                                                                            uint32_t pname,
+                                                                            struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl2_get_active_uniforms(uint32_t program,
+                                                             const uint32_t *uniform_indices,
+                                                             uintptr_t size,
+                                                             uint32_t pname,
+                                                             struct WebGLState *state);
+
+void canvas_native_webgl2_get_buffer_sub_data(uint32_t target,
+                                              intptr_t src_byte_offset,
+                                              uint8_t *dst_data,
+                                              uintptr_t size,
+                                              uintptr_t dst_offset,
+                                              uintptr_t length,
+                                              struct WebGLState *state);
+
+int32_t canvas_native_webgl2_get_frag_data_location(uint32_t program,
+                                                    const char *name,
+                                                    struct WebGLState *state);
+
+struct WebGLIndexedParameter *canvas_native_webgl2_get_indexed_parameter(uint32_t target,
+                                                                         uint32_t index,
+                                                                         struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl2_get_internalformat_parameter(uint32_t target,
+                                                                      uint32_t internalformat,
+                                                                      uint32_t pname,
+                                                                      struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl2_get_parameter(uint32_t pname, struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl2_get_query_parameter(uint32_t query,
+                                                             uint32_t pname,
+                                                             struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl2_get_query(uint32_t target,
+                                                   uint32_t pname,
+                                                   struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl2_get_sampler_parameter(uint32_t sampler,
+                                                               uint32_t pname,
+                                                               struct WebGLState *state);
+
+struct WebGLResult *canvas_native_webgl2_get_sync_parameter(const struct WebGLSync *sync,
+                                                            uint32_t pname,
+                                                            struct WebGLState *state);
+
+struct WebGLActiveInfo *canvas_native_webgl2_get_transform_feedback_varying(uint32_t program,
+                                                                            uint32_t index,
+                                                                            struct WebGLState *state);
+
+uint32_t canvas_native_webgl2_get_uniform_block_index(uint32_t program,
+                                                      const char *uniform_block_name,
+                                                      struct WebGLState *state);
+
+struct U32Buffer *canvas_native_webgl2_get_uniform_indices(uint32_t program,
+                                                           const char *const *uniform_names,
+                                                           uintptr_t size,
+                                                           struct WebGLState *state);
+
+void canvas_native_webgl2_invalidate_framebuffer(uint32_t target,
+                                                 const uint32_t *attachments,
+                                                 uintptr_t size,
+                                                 struct WebGLState *state);
+
+void canvas_native_webgl2_invalidate_sub_framebuffer(uint32_t target,
+                                                     const uint32_t *attachments,
+                                                     uintptr_t size,
+                                                     int32_t x,
+                                                     int32_t y,
+                                                     int32_t width,
+                                                     int32_t height,
+                                                     struct WebGLState *state);
+
+bool canvas_native_webgl2_is_query(uint32_t query, struct WebGLState *state);
+
+bool canvas_native_webgl2_is_sampler(uint32_t sampler, struct WebGLState *state);
+
+bool canvas_native_webgl2_is_sync(const struct WebGLSync *sync, struct WebGLState *state);
+
+bool canvas_native_webgl2_is_transform_feedback(uint32_t transform_feedback,
+                                                struct WebGLState *state);
+
+bool canvas_native_webgl2_is_vertex_array(uint32_t vertex_array, struct WebGLState *state);
+
+void canvas_native_webgl2_pause_transform_feedback(struct WebGLState *state);
+
+void canvas_native_webgl2_read_buffer(uint32_t src, struct WebGLState *state);
+
+void canvas_native_webgl2_renderbuffer_storage_multisample(uint32_t target,
+                                                           int32_t samples,
+                                                           uint32_t internal_format,
+                                                           int32_t width,
+                                                           int32_t height,
+                                                           struct WebGLState *state);
+
+void canvas_native_webgl2_resume_transform_feedback(struct WebGLState *state);
+
+void canvas_native_webgl2_sampler_parameterf(uint32_t sampler,
+                                             uint32_t pname,
+                                             float param,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl2_sampler_parameteri(uint32_t sampler,
+                                             uint32_t pname,
+                                             int32_t param,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image3d_none(uint32_t target,
+                                           int32_t level,
+                                           int32_t internalformat,
+                                           int32_t width,
+                                           int32_t height,
+                                           int32_t depth,
+                                           int32_t border,
+                                           uint32_t format,
+                                           uint32_t type_,
+                                           uintptr_t offset,
+                                           struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image3d_asset(uint32_t target,
+                                            int32_t level,
+                                            int32_t internalformat,
+                                            int32_t width,
+                                            int32_t height,
+                                            int32_t depth,
+                                            int32_t border,
+                                            uint32_t format,
+                                            uint32_t type_,
+                                            const struct ImageAsset *asset,
+                                            struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image3d(uint32_t target,
+                                      int32_t level,
+                                      int32_t internalformat,
+                                      int32_t width,
+                                      int32_t height,
+                                      int32_t depth,
+                                      int32_t border,
+                                      uint32_t format,
+                                      uint32_t type_,
+                                      const uint8_t *buf,
+                                      uintptr_t size,
+                                      struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image3d_offset(uint32_t target,
+                                             int32_t level,
+                                             int32_t internalformat,
                                              int32_t width,
                                              int32_t height,
-                                             uint8_t *bytes,
+                                             int32_t depth,
+                                             int32_t border,
+                                             uint32_t format,
+                                             uint32_t type_,
+                                             const uint8_t *buf,
                                              uintptr_t size,
-                                             const char *repetition);
-
-bool canvas_native_context_draw_image_dx_dy_with_bytes(int64_t context,
-                                                       uint8_t *bytes,
-                                                       uintptr_t size,
-                                                       float width,
-                                                       float height,
-                                                       float dx,
-                                                       float dy);
-
-bool canvas_native_context_draw_image_dx_dy_dw_dh_with_bytes(int64_t context,
-                                                             uint8_t *bytes,
-                                                             uintptr_t size,
-                                                             float width,
-                                                             float height,
-                                                             float dx,
-                                                             float dy,
-                                                             float d_width,
-                                                             float d_height);
-
-bool canvas_native_context_draw_image_with_bytes(int64_t context,
-                                                 uint8_t *bytes,
+                                             uintptr_t offset,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl2_tex_storage2d(uint32_t target,
+                                        int32_t levels,
+                                        uint32_t internalformat,
+                                        int32_t width,
+                                        int32_t height,
+                                        struct WebGLState *state);
+
+void canvas_native_webgl2_tex_storage3d(uint32_t target,
+                                        int32_t levels,
+                                        uint32_t internalformat,
+                                        int32_t width,
+                                        int32_t height,
+                                        int32_t depth,
+                                        struct WebGLState *state);
+
+void canvas_native_webgl2_tex_sub_image3d_none(uint32_t target,
+                                               int32_t level,
+                                               int32_t xoffset,
+                                               int32_t yoffset,
+                                               int32_t zoffset,
+                                               int32_t width,
+                                               int32_t height,
+                                               int32_t depth,
+                                               uint32_t format,
+                                               uint32_t type_,
+                                               uintptr_t offset,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl2_tex_sub_image3d(uint32_t target,
+                                          int32_t level,
+                                          int32_t xoffset,
+                                          int32_t yoffset,
+                                          int32_t zoffset,
+                                          int32_t width,
+                                          int32_t height,
+                                          int32_t depth,
+                                          uint32_t format,
+                                          uint32_t type_,
+                                          const uint8_t *buf,
+                                          uintptr_t size,
+                                          struct WebGLState *state);
+
+void canvas_native_webgl2_tex_sub_image3d_asset(uint32_t target,
+                                                int32_t level,
+                                                int32_t xoffset,
+                                                int32_t yoffset,
+                                                int32_t zoffset,
+                                                int32_t width,
+                                                int32_t height,
+                                                int32_t depth,
+                                                uint32_t format,
+                                                uint32_t type_,
+                                                const struct ImageAsset *asset,
+                                                struct WebGLState *state);
+
+void canvas_native_webgl2_tex_sub_image3d_offset(uint32_t target,
+                                                 int32_t level,
+                                                 int32_t xoffset,
+                                                 int32_t yoffset,
+                                                 int32_t zoffset,
+                                                 int32_t width,
+                                                 int32_t height,
+                                                 int32_t depth,
+                                                 uint32_t format,
+                                                 uint32_t type_,
+                                                 const uint8_t *buf,
                                                  uintptr_t size,
-                                                 float width,
-                                                 float height,
-                                                 float sx,
-                                                 float sy,
-                                                 float s_width,
-                                                 float s_height,
-                                                 float dx,
-                                                 float dy,
-                                                 float d_width,
-                                                 float d_height);
-
-#endif /* CBINDGEN_BINDINGS_H */
+                                                 uintptr_t offset,
+                                                 struct WebGLState *state);
+
+void canvas_native_webgl2_transform_feedback_varyings(uint32_t program,
+                                                      const char *const *varyings,
+                                                      uintptr_t size,
+                                                      uint32_t buffer_mode,
+                                                      struct WebGLState *state);
+
+void canvas_native_webgl2_uniform1ui(int32_t location, uint32_t v0, struct WebGLState *state);
+
+void canvas_native_webgl2_uniform1uiv(int32_t location,
+                                      const uint32_t *data,
+                                      uintptr_t size,
+                                      struct WebGLState *state);
+
+void canvas_native_webgl2_uniform2ui(int32_t location,
+                                     uint32_t v0,
+                                     uint32_t v1,
+                                     struct WebGLState *state);
+
+void canvas_native_webgl2_uniform2uiv(int32_t location,
+                                      const uint32_t *data,
+                                      uintptr_t size,
+                                      struct WebGLState *state);
+
+void canvas_native_webgl2_uniform3ui(int32_t location,
+                                     uint32_t v0,
+                                     uint32_t v1,
+                                     uint32_t v2,
+                                     struct WebGLState *state);
+
+void canvas_native_webgl2_uniform3uiv(int32_t location,
+                                      const uint32_t *data,
+                                      uintptr_t size,
+                                      struct WebGLState *state);
+
+void canvas_native_webgl2_uniform4ui(int32_t location,
+                                     uint32_t v0,
+                                     uint32_t v1,
+                                     uint32_t v2,
+                                     uint32_t v3,
+                                     struct WebGLState *state);
+
+void canvas_native_webgl2_uniform4uiv(int32_t location,
+                                      const uint32_t *data,
+                                      uintptr_t size,
+                                      struct WebGLState *state);
+
+void canvas_native_webgl2_uniform_block_binding(uint32_t program,
+                                                uint32_t uniform_block_index,
+                                                uint32_t uniform_block_binding,
+                                                struct WebGLState *state);
+
+void canvas_native_webgl2_uniform_matrix2x3fv(int32_t location,
+                                              bool transpose,
+                                              const float *data,
+                                              uintptr_t size,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl2_uniform_matrix2x4fv(int32_t location,
+                                              bool transpose,
+                                              const float *data,
+                                              uintptr_t size,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl2_uniform_matrix3x2fv(int32_t location,
+                                              bool transpose,
+                                              const float *data,
+                                              uintptr_t size,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl2_uniform_matrix3x4fv(int32_t location,
+                                              bool transpose,
+                                              const float *data,
+                                              uintptr_t size,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl2_uniform_matrix4x2fv(int32_t location,
+                                              bool transpose,
+                                              const float *data,
+                                              uintptr_t size,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl2_uniform_matrix4x3fv(int32_t location,
+                                              bool transpose,
+                                              const float *data,
+                                              uintptr_t size,
+                                              struct WebGLState *state);
+
+void canvas_native_webgl2_vertex_attrib_divisor(uint32_t index,
+                                                uint32_t divisor,
+                                                struct WebGLState *state);
+
+void canvas_native_webgl2_vertex_attrib_i4i(uint32_t index,
+                                            int32_t x,
+                                            int32_t y,
+                                            int32_t z,
+                                            int32_t w,
+                                            struct WebGLState *state);
+
+void canvas_native_webgl2_vertex_attrib_i4iv(uint32_t index,
+                                             const int32_t *value,
+                                             uintptr_t size,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl2_vertex_attrib_i4ui(uint32_t index,
+                                             uint32_t x,
+                                             uint32_t y,
+                                             uint32_t z,
+                                             uint32_t w,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl2_vertex_attrib_i4uiv(uint32_t index,
+                                              const uint32_t *value,
+                                              uintptr_t size,
+                                              struct WebGLState *state);
+
+void canvas_native_image_asset_destroy(struct ImageAsset *asset);
+
+void canvas_native_string_destroy(char *value);
+
+void canvas_native_image_data_destroy(struct ImageData *value);
+
+void canvas_native_matrix_destroy(struct Matrix *value);
+
+void canvas_native_path_destroy(struct Path *value);
+
+const uint8_t *canvas_native_u8_buffer_get_bytes(const struct U8Buffer *buffer);
+
+uint8_t *canvas_native_u8_buffer_get_bytes_mut(struct U8Buffer *buffer);
+
+void canvas_native_u8_buffer_destroy(struct U8Buffer *buffer);
+
+uintptr_t canvas_native_u8_buffer_mut_get_length(const struct U8Buffer *buffer);
+
+uintptr_t canvas_native_u8_buffer_get_length(const struct U8Buffer *buffer);
+
+const uint16_t *canvas_native_u16_buffer_get_bytes(const struct U16Buffer *buffer);
+
+uint16_t *canvas_native_u16_buffer_get_bytes_mut(struct U16Buffer *buffer);
+
+void canvas_native_u16_buffer_destroy(struct U16Buffer *buffer);
+
+uintptr_t canvas_native_u16_buffer_mut_get_length(const struct U16Buffer *buffer);
+
+uintptr_t canvas_native_u16_buffer_get_length(const struct U16Buffer *buffer);
+
+const uint32_t *canvas_native_u32_buffer_get_bytes(const struct U32Buffer *buffer);
+
+uint32_t *canvas_native_u32_buffer_get_bytes_mut(struct U32Buffer *buffer);
+
+void canvas_native_u32_buffer_destroy(struct U32Buffer *buffer);
+
+uintptr_t canvas_native_u32_buffer_mut_get_length(const struct U32Buffer *buffer);
+
+uintptr_t canvas_native_u32_buffer_get_length(const struct U32Buffer *buffer);
+
+const int32_t *canvas_native_i32_buffer_get_bytes(const struct I32Buffer *buffer);
+
+int32_t *canvas_native_i32_buffer_get_bytes_mut(struct I32Buffer *buffer);
+
+void canvas_native_i32_buffer_destroy(struct I32Buffer *buffer);
+
+uintptr_t canvas_native_i32_buffer_mut_get_length(const struct I32Buffer *buffer);
+
+uintptr_t canvas_native_i32_buffer_get_length(const struct I32Buffer *buffer);
+
+const float *canvas_native_f32_buffer_get_bytes(const struct F32Buffer *buffer);
+
+float *canvas_native_f32_buffer_get_bytes_mut(struct F32Buffer *buffer);
+
+void canvas_native_f32_buffer_destroy(struct F32Buffer *buffer);
+
+uintptr_t canvas_native_f32_buffer_mut_get_length(const struct F32Buffer *buffer);
+
+uintptr_t canvas_native_f32_buffer_get_length(const struct F32Buffer *buffer);
+
+uintptr_t canvas_native_string_buffer_get_length(const struct StringBuffer *buffer);
+
+char *canvas_native_string_buffer_get_value_at(const struct StringBuffer *buffer, uintptr_t index);
+
+void canvas_native_string_buffer_destroy(struct StringBuffer *buffer);
+
+bool canvas_url_can_parse(const char *value, const char *base);
+
+struct URL *canvas_url_create(const char *value, const char *base);
+
+void canvas_url_destroy(struct URL *url);
+
+struct CCow *canvas_url_to_string(struct URL *url);
+
+const char *canvas_url_hash(struct URL *url);
+
+void canvas_url_set_hash(struct URL *url, const char *hash);
+
+const char *canvas_url_host(struct URL *url);
+
+void canvas_url_set_host(struct URL *url, const char *host);
+
+const char *canvas_url_host_name(struct URL *url);
+
+void canvas_url_set_host_name(struct URL *url, const char *hostname);
+
+const char *canvas_url_href(struct URL *url);
+
+void canvas_url_set_href(struct URL *url, const char *href);
+
+const char *canvas_url_origin(struct URL *url);
+
+const char *canvas_url_password(struct URL *url);
+
+void canvas_url_set_password(struct URL *url, const char *password);
+
+const char *canvas_url_pathname(struct URL *url);
+
+void canvas_url_set_pathname(struct URL *url, const char *pathname);
+
+const char *canvas_url_port(struct URL *url);
+
+void canvas_url_set_port(struct URL *url, const char *port);
+
+const char *canvas_url_protocol(struct URL *url);
+
+void canvas_url_set_protocol(struct URL *url, const char *protocol);
+
+const char *canvas_url_search(struct URL *url);
+
+void canvas_url_set_search(struct URL *url, const char *search);
+
+const char *canvas_url_username(struct URL *url);
+
+void canvas_url_set_username(struct URL *url, const char *username);
+
+#endif /* CANVAS_C_H */