@nativescript/canvas 2.0.0-webgpu.4 → 2.0.0-webgpu.41

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

@@ -594,6 +594,16 @@ typedef enum PaintStyleType {
   PaintStyleTypePattern,
 } PaintStyleType;
 
+typedef enum SurfaceGetCurrentTextureStatus {
+  SurfaceGetCurrentTextureStatusSuccess = 0,
+  SurfaceGetCurrentTextureStatusTimeout = 1,
+  SurfaceGetCurrentTextureStatusOutdated = 2,
+  SurfaceGetCurrentTextureStatusLost = 3,
+  SurfaceGetCurrentTextureStatusOutOfMemory = 4,
+  SurfaceGetCurrentTextureStatusDeviceLost = 5,
+  SurfaceGetCurrentTextureStatusForce32 = 2147483647,
+} SurfaceGetCurrentTextureStatus;
+
 typedef enum TextBaseLine {
   TextBaseLineTOP = 0,
   TextBaseLineHANGING = 1,
@@ -943,7 +953,7 @@ typedef enum CanvasGPUTextureFormat_Tag {
   /**
    * Red, green, and blue channels. 11 bit float with no sign bit for RG channels. 10 bit float with no sign bit for blue channel. Float in shader.
    */
-  CanvasGPUTextureFormatRg11b10Float,
+  CanvasGPUTextureFormatRg11b10UFloat,
   /**
    * Red and green channels. 32 bit integer per channel. Unsigned in shader.
    */
@@ -1760,6 +1770,75 @@ typedef struct CanvasOrigin2d {
   uint32_t y;
 } CanvasOrigin2d;
 
+typedef struct CanvasImageCopyWebGL {
+  /**
+   * The texture to be copied from. The copy source data is captured at the moment
+   * the copy is issued.
+   */
+  const struct WebGLState *source;
+  /**
+   * The base texel used for copying from the external image. Together
+   * with the `copy_size` argument to copy functions, defines the
+   * sub-region of the image to copy.
+   *
+   * Relative to the top left of the image.
+   *
+   * Must be [`Origin2d::ZERO`] if [`DownlevelFlags::UNRESTRICTED_EXTERNAL_TEXTURE_COPIES`] is not supported.
+   */
+  struct CanvasOrigin2d origin;
+  /**
+   * If the Y coordinate of the image should be flipped. Even if this is
+   * true, `origin` is still relative to the top left.
+   */
+  bool flip_y;
+} CanvasImageCopyWebGL;
+
+typedef struct CanvasImageCopyCanvasRenderingContext2D {
+  /**
+   * The texture to be copied from. The copy source data is captured at the moment
+   * the copy is issued.
+   */
+  const struct CanvasRenderingContext2D *source;
+  /**
+   * The base texel used for copying from the external image. Together
+   * with the `copy_size` argument to copy functions, defines the
+   * sub-region of the image to copy.
+   *
+   * Relative to the top left of the image.
+   *
+   * Must be [`Origin2d::ZERO`] if [`DownlevelFlags::UNRESTRICTED_EXTERNAL_TEXTURE_COPIES`] is not supported.
+   */
+  struct CanvasOrigin2d origin;
+  /**
+   * If the Y coordinate of the image should be flipped. Even if this is
+   * true, `origin` is still relative to the top left.
+   */
+  bool flip_y;
+} CanvasImageCopyCanvasRenderingContext2D;
+
+typedef struct CanvasImageCopyImageAsset {
+  /**
+   * The texture to be copied from. The copy source data is captured at the moment
+   * the copy is issued.
+   */
+  const struct ImageAsset *source;
+  /**
+   * The base texel used for copying from the external image. Together
+   * with the `copy_size` argument to copy functions, defines the
+   * sub-region of the image to copy.
+   *
+   * Relative to the top left of the image.
+   *
+   * Must be [`Origin2d::ZERO`] if [`DownlevelFlags::UNRESTRICTED_EXTERNAL_TEXTURE_COPIES`] is not supported.
+   */
+  struct CanvasOrigin2d origin;
+  /**
+   * If the Y coordinate of the image should be flipped. Even if this is
+   * true, `origin` is still relative to the top left.
+   */
+  bool flip_y;
+} CanvasImageCopyImageAsset;
+
 typedef struct CanvasImageCopyExternalImage {
   /**
    * The texture to be copied from. The copy source data is captured at the moment
@@ -1807,10 +1886,21 @@ typedef struct CanvasCreateTextureViewDescriptor {
   const struct CanvasImageSubresourceRange *range;
 } CanvasCreateTextureViewDescriptor;
 
+typedef struct FileHelperMime {
+  const char *mime_type;
+  const char *extension;
+} FileHelperMime;
+
 void canvas_native_font_add_family(const char *alias,
                                    const char *const *filenames,
                                    uintptr_t length);
 
+void canvas_native_context_2d_test(int64_t context);
+
+void canvas_native_context_2d_path_test(int64_t context);
+
+void canvas_native_context_2d_conic_test(int64_t context);
+
 void canvas_native_context_release(struct CanvasRenderingContext2D *value);
 
 #if (defined(TARGET_OS_ANDROID) || defined(TARGET_OS_IOS))
@@ -1846,11 +1936,10 @@ struct CanvasRenderingContext2D *canvas_native_context_create(float width,
                                                               float ppi,
                                                               uint32_t direction);
 
-struct CanvasRenderingContext2D *canvas_native_context_create_gl(float width,
+struct CanvasRenderingContext2D *canvas_native_context_create_gl(void *view,
+                                                                 float width,
                                                                  float height,
                                                                  float density,
-                                                                 int64_t gl_context,
-                                                                 int32_t samples,
                                                                  bool alpha,
                                                                  int32_t font_color,
                                                                  float ppi,
@@ -2105,7 +2194,7 @@ struct PaintStyle *canvas_native_context_create_pattern(const struct CanvasRende
                                                         enum CanvasRepetition repetition);
 
 struct PaintStyle *canvas_native_context_create_pattern_asset(struct CanvasRenderingContext2D *context,
-                                                              struct ImageAsset *asset,
+                                                              const struct ImageAsset *asset,
                                                               enum CanvasRepetition repetition);
 
 struct PaintStyle *canvas_native_context_create_pattern_encoded(struct CanvasRenderingContext2D *context,
@@ -2198,14 +2287,14 @@ void canvas_native_context_draw_image_dx_dy_asset(struct CanvasRenderingContext2
                                                   float dy);
 
 void canvas_native_context_draw_image_dx_dy_dw_dh_asset(struct CanvasRenderingContext2D *context,
-                                                        struct ImageAsset *asset,
+                                                        const 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,
+                                            const struct ImageAsset *asset,
                                             float sx,
                                             float sy,
                                             float s_width,
@@ -2286,7 +2375,7 @@ void canvas_native_context_draw_atlas_encoded(struct CanvasRenderingContext2D *c
                                               int32_t blend_mode);
 
 void canvas_native_context_draw_atlas_asset(struct CanvasRenderingContext2D *context,
-                                            struct ImageAsset *asset,
+                                            const struct ImageAsset *asset,
                                             const float *xform,
                                             uintptr_t xform_size,
                                             const float *tex,
@@ -2490,34 +2579,34 @@ void canvas_native_image_filter_reference(const struct ImageFilter *value);
 
 void canvas_native_image_filter_release(const struct ImageFilter *value);
 
-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);
+const struct ImageAsset *canvas_native_image_bitmap_create_from_asset(const 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);
+
+const struct ImageAsset *canvas_native_image_bitmap_create_from_asset_src_rect(const 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);
+
+const 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,
@@ -2527,20 +2616,20 @@ bool canvas_native_image_bitmap_create_from_encoded_bytes_with_output(const uint
                                                                       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);
+                                                                      const struct ImageAsset *output);
+
+const 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,
@@ -2554,7 +2643,7 @@ bool canvas_native_image_bitmap_create_from_encoded_bytes_src_rect_with_output(c
                                                                                enum ImageBitmapResizeQuality resize_quality,
                                                                                float resize_width,
                                                                                float resize_height,
-                                                                               struct ImageAsset *output);
+                                                                               const struct ImageAsset *output);
 
 struct ImageData *canvas_native_image_data_create(int32_t width, int32_t height);
 
@@ -2876,14 +2965,20 @@ void canvas_native_webgpu_adapter_info_reference(const struct CanvasGPUAdapterIn
 
 void canvas_native_webgpu_adapter_info_release(const struct CanvasGPUAdapterInfo *info);
 
+char *canvas_native_webgpu_bind_group_get_label(const struct CanvasGPUBindGroup *bind_group);
+
 void canvas_native_webgpu_bind_group_reference(const struct CanvasGPUBindGroup *bind_group);
 
 void canvas_native_webgpu_bind_group_release(const struct CanvasGPUBindGroup *bind_group);
 
+char *canvas_native_webgpu_bind_group_layout_get_label(const struct CanvasGPUBindGroupLayout *bind_group_layout);
+
 void canvas_native_webgpu_bind_group_layout_reference(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
 void canvas_native_webgpu_bind_group_layout_release(const struct CanvasGPUBindGroupLayout *bind_group_layout);
 
+char *canvas_native_webgpu_buffer_get_label(const struct CanvasGPUBuffer *buffer);
+
 void canvas_native_webgpu_buffer_reference(const struct CanvasGPUBuffer *buffer);
 
 void canvas_native_webgpu_buffer_release(const struct CanvasGPUBuffer *buffer);
@@ -2904,7 +2999,7 @@ void canvas_native_webgpu_buffer_map_async(const struct CanvasGPUBuffer *buffer,
                                            enum GPUMapMode mode,
                                            int64_t offset,
                                            int64_t size,
-                                           void (*callback)(char*, void*),
+                                           void (*callback)(enum CanvasGPUErrorType, char*, void*),
                                            void *callback_data);
 
 #if defined(TARGET_OS_ANDROID)
@@ -2914,6 +3009,13 @@ const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(struct
                                                                          uint32_t height);
 #endif
 
+#if defined(TARGET_OS_ANDROID)
+void canvas_native_webgpu_context_resize(struct CanvasGPUCanvasContext *context,
+                                         void *window,
+                                         uint32_t width,
+                                         uint32_t height);
+#endif
+
 #if (defined(TARGET_OS_IOS) || defined(TARGET_OS_MACOS))
 const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create(const struct CanvasWebGPUInstance *instance,
                                                                          void *view,
@@ -2928,6 +3030,13 @@ const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_uiview(
                                                                                 uint32_t height);
 #endif
 
+#if defined(TARGET_OS_IOS)
+void canvas_native_webgpu_context_resize_uiview(const struct CanvasGPUCanvasContext *context,
+                                                void *view,
+                                                uint32_t width,
+                                                uint32_t height);
+#endif
+
 #if defined(TARGET_OS_MACOS)
 const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(const struct CanvasWebGPUInstance *instance,
                                                                                 void *view,
@@ -2935,13 +3044,18 @@ const struct CanvasGPUCanvasContext *canvas_native_webgpu_context_create_nsview(
                                                                                 uint32_t height);
 #endif
 
+#if defined(TARGET_OS_MACOS)
+void canvas_native_webgpu_context_resize_nsview(const struct CanvasGPUCanvasContext *context,
+                                                void *view,
+                                                uint32_t width,
+                                                uint32_t height);
+#endif
+
 void canvas_native_webgpu_context_configure(const struct CanvasGPUCanvasContext *context,
                                             const struct CanvasGPUDevice *device,
                                             const struct CanvasGPUSurfaceConfiguration *config);
 
-void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context,
-                                              struct CanvasGPUDevice *device,
-                                              const struct CanvasGPUSurfaceConfiguration *config);
+void canvas_native_webgpu_context_unconfigure(const struct CanvasGPUCanvasContext *context);
 
 const struct CanvasGPUTexture *canvas_native_webgpu_context_get_current_texture(const struct CanvasGPUCanvasContext *context);
 
@@ -2955,10 +3069,14 @@ void canvas_native_webgpu_context_reference(const struct CanvasGPUCanvasContext
 
 void canvas_native_webgpu_context_release(const struct CanvasGPUCanvasContext *context);
 
+char *canvas_native_webgpu_command_buffer_get_label(const struct CanvasGPUCommandBuffer *command_buffer);
+
 void canvas_native_webgpu_command_buffer_reference(const struct CanvasGPUCommandBuffer *command_buffer);
 
 void canvas_native_webgpu_command_buffer_release(const struct CanvasGPUCommandBuffer *command_buffer);
 
+char *canvas_native_webgpu_command_encoder_get_label(const struct CanvasGPUCommandEncoder *command_encoder);
+
 void canvas_native_webgpu_command_encoder_reference(const struct CanvasGPUCommandEncoder *command_encoder);
 
 void canvas_native_webgpu_command_encoder_release(const struct CanvasGPUCommandEncoder *command_encoder);
@@ -3028,6 +3146,8 @@ void canvas_native_webgpu_command_encoder_write_timestamp(const struct CanvasGPU
                                                           const struct CanvasGPUQuerySet *query_set,
                                                           uint32_t query_index);
 
+char *canvas_native_webgpu_compute_pass_encoder_get_label(const struct CanvasGPUComputePassEncoder *compute_pass);
+
 void canvas_native_webgpu_compute_pass_encoder_reference(const struct CanvasGPUComputePassEncoder *compute_pass);
 
 void canvas_native_webgpu_compute_pass_encoder_release(const struct CanvasGPUComputePassEncoder *compute_pass);
@@ -3062,6 +3182,8 @@ void canvas_native_webgpu_compute_pass_encoder_set_bind_group(const struct Canva
 void canvas_native_webgpu_compute_pass_encoder_set_pipeline(const struct CanvasGPUComputePassEncoder *compute_pass,
                                                             const struct CanvasGPUComputePipeline *pipeline);
 
+char *canvas_native_webgpu_compute_pipeline_get_label(const struct CanvasGPUComputePipeline *pipeline);
+
 void canvas_native_webgpu_compute_pipeline_reference(const struct CanvasGPUComputePipeline *pipeline);
 
 void canvas_native_webgpu_compute_pipeline_release(const struct CanvasGPUComputePipeline *pipeline);
@@ -3069,6 +3191,8 @@ void canvas_native_webgpu_compute_pipeline_release(const struct CanvasGPUCompute
 const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_compute_pipeline_get_bind_group_layout(const struct CanvasGPUComputePipeline *pipeline,
                                                                                                    uint32_t index);
 
+char *canvas_native_webgpu_device_get_label(const struct CanvasGPUDevice *device);
+
 struct StringBuffer *canvas_native_webgpu_device_get_features(const struct CanvasGPUDevice *device);
 
 struct CanvasGPUSupportedLimits *canvas_native_webgpu_device_get_limits(const struct CanvasGPUDevice *device);
@@ -3177,6 +3301,8 @@ const struct CanvasGPUTexture *canvas_native_webgpu_device_create_texture(const
 const struct CanvasGPUSampler *canvas_native_webgpu_device_create_sampler(const struct CanvasGPUDevice *device,
                                                                           const struct CanvasCreateSamplerDescriptor *descriptor);
 
+char *canvas_native_webgpu_pipeline_layout_get_label(const struct CanvasGPUPipelineLayout *pipeline_layout);
+
 void canvas_native_webgpu_pipeline_layout_reference(const struct CanvasGPUPipelineLayout *pipeline_layout);
 
 void canvas_native_webgpu_pipeline_layout_release(const struct CanvasGPUPipelineLayout *pipeline_layout);
@@ -3193,10 +3319,27 @@ void canvas_native_webgpu_query_set_reference(const struct CanvasGPUQuerySet *qu
 
 void canvas_native_webgpu_query_set_release(const struct CanvasGPUQuerySet *query_set);
 
+char *canvas_native_webgpu_queue_get_label(const struct CanvasGPUQueue *queue);
+
 void canvas_native_webgpu_queue_reference(const struct CanvasGPUQueue *queue);
 
 void canvas_native_webgpu_queue_release(const struct CanvasGPUQueue *queue);
 
+void canvas_native_webgpu_queue_copy_webgl_to_texture(const struct CanvasGPUQueue *queue,
+                                                      const struct CanvasImageCopyWebGL *source,
+                                                      const struct CanvasImageCopyTexture *destination,
+                                                      const struct CanvasExtent3d *size);
+
+void canvas_native_webgpu_queue_copy_context_to_texture(const struct CanvasGPUQueue *queue,
+                                                        const struct CanvasImageCopyCanvasRenderingContext2D *source,
+                                                        const struct CanvasImageCopyTexture *destination,
+                                                        const struct CanvasExtent3d *size);
+
+void canvas_native_webgpu_queue_copy_image_asset_to_texture(const struct CanvasGPUQueue *queue,
+                                                            const struct CanvasImageCopyImageAsset *source,
+                                                            const struct CanvasImageCopyTexture *destination,
+                                                            const struct CanvasExtent3d *size);
+
 void canvas_native_webgpu_queue_copy_external_image_to_texture(const struct CanvasGPUQueue *queue,
                                                                const struct CanvasImageCopyExternalImage *source,
                                                                const struct CanvasImageCopyTexture *destination,
@@ -3225,10 +3368,14 @@ void canvas_native_webgpu_queue_write_texture(const struct CanvasGPUQueue *queue
                                               const uint8_t *buf,
                                               uintptr_t buf_size);
 
+char *canvas_native_webgpu_render_bundle_get_label(const struct CanvasGPURenderBundle *bundle);
+
 void canvas_native_webgpu_render_bundle_reference(const struct CanvasGPURenderBundle *bundle);
 
 void canvas_native_webgpu_render_bundle_release(const struct CanvasGPURenderBundle *bundle);
 
+char *canvas_native_webgpu_render_bundle_encoder_get_label(const struct CanvasGPURenderBundleEncoder *render_bundle);
+
 void canvas_native_webgpu_render_bundle_encoder_draw(const struct CanvasGPURenderBundleEncoder *render_bundle,
                                                      uint32_t vertex_count,
                                                      uint32_t instance_count,
@@ -3288,6 +3435,8 @@ void canvas_native_webgpu_render_bundle_encoder_reference(const struct CanvasGPU
 
 void canvas_native_webgpu_render_bundle_encoder_release(const struct CanvasGPURenderBundleEncoder *render_bundle);
 
+char *canvas_native_webgpu_render_pass_encoder_get_label(const struct CanvasGPURenderPassEncoder *render_pass);
+
 void canvas_native_webgpu_render_pass_encoder_begin_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass,
                                                                     uint32_t query_index);
 
@@ -3308,10 +3457,20 @@ void canvas_native_webgpu_render_pass_encoder_draw_indexed_indirect(const struct
                                                                     const struct CanvasGPUBuffer *indirect_buffer,
                                                                     uint64_t indirect_offset);
 
+void canvas_native_webgpu_render_pass_encoder_multi_draw_indexed_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                                          const struct CanvasGPUBuffer *indirect_buffer,
+                                                                          uint64_t indirect_offset,
+                                                                          uint32_t count);
+
 void canvas_native_webgpu_render_pass_encoder_draw_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
                                                             const struct CanvasGPUBuffer *indirect_buffer,
                                                             uint64_t indirect_offset);
 
+void canvas_native_webgpu_render_pass_encoder_multi_draw_indirect(const struct CanvasGPURenderPassEncoder *render_pass,
+                                                                  const struct CanvasGPUBuffer *indirect_buffer,
+                                                                  uint64_t indirect_offset,
+                                                                  uint32_t count);
+
 void canvas_native_webgpu_render_pass_encoder_end(const struct CanvasGPURenderPassEncoder *render_pass);
 
 void canvas_native_webgpu_render_pass_encoder_end_occlusion_query(const struct CanvasGPURenderPassEncoder *render_pass);
@@ -3379,13 +3538,19 @@ void canvas_native_webgpu_render_pipeline_reference(const struct CanvasGPURender
 
 void canvas_native_webgpu_render_pipeline_release(const struct CanvasGPURenderPipeline *pipeline);
 
+char *canvas_native_webgpu_render_pipeline_get_label(const struct CanvasGPURenderPipeline *pipeline);
+
 const struct CanvasGPUBindGroupLayout *canvas_native_webgpu_render_pipeline_get_bind_group_layout(const struct CanvasGPURenderPipeline *pipeline,
                                                                                                   uint32_t index);
 
+char *canvas_native_webgpu_sampler_get_label(const struct CanvasGPUSampler *sampler);
+
 void canvas_native_webgpu_sampler_reference(const struct CanvasGPUSampler *sampler);
 
 void canvas_native_webgpu_sampler_release(const struct CanvasGPUSampler *sampler);
 
+char *canvas_native_webgpu_shader_module_get_label(const struct CanvasGPUShaderModule *shader_module);
+
 void canvas_native_webgpu_shader_module_reference(const struct CanvasGPUShaderModule *shader_module);
 
 void canvas_native_webgpu_shader_module_release(const struct CanvasGPUShaderModule *shader_module);
@@ -3394,6 +3559,12 @@ struct CanvasGPUSupportedLimits *canvas_native_webgpu_create_limits(void);
 
 void canvas_native_webgpu_limits_release(struct CanvasGPUSupportedLimits *limits);
 
+enum SurfaceGetCurrentTextureStatus canvas_native_webgpu_texture_get_status(const struct CanvasGPUTexture *texture);
+
+bool canvas_native_webgpu_texture_get_suboptimal(const struct CanvasGPUTexture *texture);
+
+char *canvas_native_webgpu_texture_get_label(const struct CanvasGPUTexture *texture);
+
 void canvas_native_webgpu_texture_reference(const struct CanvasGPUTexture *texture);
 
 void canvas_native_webgpu_texture_release(const struct CanvasGPUTexture *texture);
@@ -3413,14 +3584,14 @@ struct CanvasGPUTextureFormat canvas_native_webgpu_texture_get_format(const stru
 
 uint32_t canvas_native_webgpu_texture_get_usage(const struct CanvasGPUTexture *texture);
 
-char *canvas_native_webgpu_texture_get_label(const struct CanvasGPUTexture *_texture);
-
 uint32_t canvas_native_webgpu_texture_get_mip_level_count(const struct CanvasGPUTexture *texture);
 
 uint32_t canvas_native_webgpu_texture_get_sample_count(const struct CanvasGPUTexture *texture);
 
 void canvas_native_webgpu_texture_destroy(const struct CanvasGPUTexture *texture);
 
+char *canvas_native_webgpu_texture_view_get_label(const struct CanvasGPUTextureView *texture_view);
+
 void canvas_native_webgpu_texture_view_reference(const struct CanvasGPUTextureView *texture_view);
 
 void canvas_native_webgpu_texture_view_release(const struct CanvasGPUTextureView *texture_view);
@@ -3473,32 +3644,50 @@ char *canvas_native_string_buffer_get_value_at(const struct StringBuffer *buffer
 
 void canvas_native_string_buffer_release(struct StringBuffer *buffer);
 
+struct FileHelperMime *canvas_native_helper_get_mime(const uint8_t *data, uintptr_t size);
+
+void canvas_native_helper_release_mime(struct FileHelperMime *mime);
+
 void canvas_native_helper_release(struct FileHelper *value);
 
 struct FileHelper *canvas_native_helper_read_file(const char *path);
 
+char *canvas_native_helper_read_file_get_mime(struct FileHelper *file);
+
+char *canvas_native_helper_read_file_get_extension(struct FileHelper *file);
+
 bool canvas_native_helper_read_file_has_error(const struct FileHelper *file);
 
 struct U8Buffer *canvas_native_helper_read_file_get_data(struct FileHelper *file);
 
+struct U8Buffer *canvas_native_helper_read_file_take_data(struct FileHelper *file);
+
 const char *canvas_native_helper_read_file_get_error(const struct FileHelper *file);
 
-int64_t canvas_native_image_asset_get_addr(struct ImageAsset *asset);
+int64_t canvas_native_image_asset_get_addr(const struct ImageAsset *asset);
+
+void canvas_native_image_asset_close(const struct ImageAsset *asset);
 
-struct ImageAsset *canvas_native_image_asset_create(void);
+const struct ImageAsset *canvas_native_image_asset_create(void);
 
-struct ImageAsset *canvas_native_image_asset_reference(struct ImageAsset *asset);
+const struct ImageAsset *canvas_native_image_asset_reference(const struct ImageAsset *asset);
 
-void canvas_native_image_asset_release(struct ImageAsset *asset);
+void canvas_native_image_asset_release(const struct ImageAsset *asset);
 
 bool canvas_native_image_asset_load_from_fd(const struct ImageAsset *asset, int fd);
 
 bool canvas_native_image_asset_load_from_path(const struct ImageAsset *asset, const char *path);
 
 bool canvas_native_image_asset_load_from_raw(const struct ImageAsset *asset,
+                                             uint32_t width,
+                                             uint32_t height,
                                              const uint8_t *array,
                                              uintptr_t size);
 
+bool canvas_native_image_asset_load_from_raw_encoded(const struct ImageAsset *asset,
+                                                     const uint8_t *array,
+                                                     uintptr_t size);
+
 bool canvas_native_image_asset_load_from_url(const struct ImageAsset *asset, const char *url);
 
 int64_t canvas_native_image_asset_addr(const struct ImageAsset *asset);
@@ -3511,8 +3700,6 @@ const char *canvas_native_image_asset_get_error(const struct ImageAsset *asset);
 
 bool canvas_native_image_asset_has_error(const struct ImageAsset *asset);
 
-struct U8Buffer *canvas_native_image_asset_get_data(const struct ImageAsset *asset);
-
 void canvas_native_text_decoder_release(struct TextDecoder *value);
 
 struct TextDecoder *canvas_native_text_decoder_create(const char *decoding);
@@ -3543,10 +3730,6 @@ struct U8Buffer *canvas_native_text_encoder_encode(const struct TextEncoder *enc
 
 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,
                                                               enum CanvasRepetition repetition);
@@ -3768,7 +3951,10 @@ bool canvas_native_webgl_oes_vertex_array_object_is_vertex_array_oes(uint32_t ar
 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,
+#if defined(TARGET_OS_ANDROID)
+struct WebGLState *canvas_native_webgl_create(void *view,
+                                              int32_t width,
+                                              int32_t height,
                                               int32_t version,
                                               bool alpha,
                                               bool antialias,
@@ -3780,6 +3966,22 @@ struct WebGLState *canvas_native_webgl_create(int64_t gl_context,
                                               bool stencil,
                                               bool desynchronized,
                                               bool xr_compatible);
+#endif
+
+#if !defined(TARGET_OS_ANDROID)
+struct WebGLState *canvas_native_webgl_create(void *view,
+                                              int32_t version,
+                                              bool alpha,
+                                              bool antialias,
+                                              bool depth,
+                                              bool fail_if_major_performance_caveat,
+                                              int32_t power_preference,
+                                              bool premultiplied_alpha,
+                                              bool preserve_drawing_buffer,
+                                              bool stencil,
+                                              bool desynchronized,
+                                              bool xr_compatible);
+#endif
 
 struct WebGLState *canvas_native_webgl_create_no_window(int32_t width,
                                                         int32_t height,
@@ -4326,7 +4528,7 @@ void canvas_native_webgl_tex_image2d_image_asset(int32_t target,
                                                  int32_t internalformat,
                                                  int32_t format,
                                                  int32_t image_type,
-                                                 struct ImageAsset *image_asset,
+                                                 const struct ImageAsset *image_asset,
                                                  struct WebGLState *state);
 
 void canvas_native_webgl_tex_parameterf(uint32_t target,
@@ -4345,7 +4547,7 @@ void canvas_native_webgl_tex_sub_image2d_asset(uint32_t target,
                                                int32_t yoffset,
                                                uint32_t format,
                                                int32_t image_type,
-                                               struct ImageAsset *asset,
+                                               const struct ImageAsset *asset,
                                                struct WebGLState *state);
 
 void canvas_native_webgl_tex_sub_image2d_canvas2d(uint32_t target,
@@ -4948,8 +5150,8 @@ void canvas_native_webgl2_tex_sub_image3d_canvas2d(uint32_t target,
                                                    int32_t xoffset,
                                                    int32_t yoffset,
                                                    int32_t zoffset,
-                                                   int32_t width,
-                                                   int32_t height,
+                                                   int32_t _width,
+                                                   int32_t _height,
                                                    int32_t depth,
                                                    uint32_t format,
                                                    uint32_t type_,
@@ -5086,4 +5288,72 @@ void canvas_native_webgl2_vertex_attrib_i4uiv(uint32_t index,
                                               uintptr_t size,
                                               struct WebGLState *state);
 
+void canvas_native_webgl2_tex_image2d_image_asset(int32_t target,
+                                                  int32_t level,
+                                                  int32_t internalformat,
+                                                  uint32_t width,
+                                                  uint32_t height,
+                                                  int32_t border,
+                                                  int32_t format,
+                                                  int32_t type_,
+                                                  const struct ImageAsset *image_asset,
+                                                  struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image2d_src_data_offset(int32_t target,
+                                                      int32_t level,
+                                                      int32_t internalformat,
+                                                      uint32_t width,
+                                                      uint32_t height,
+                                                      int32_t border,
+                                                      int32_t format,
+                                                      int32_t type_,
+                                                      const uint8_t *src_data,
+                                                      uintptr_t src_data_size,
+                                                      uint64_t offset,
+                                                      struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image2d_offset(int32_t target,
+                                             int32_t level,
+                                             int32_t internalformat,
+                                             uint32_t width,
+                                             uint32_t height,
+                                             int32_t border,
+                                             int32_t format,
+                                             int32_t type_,
+                                             uint64_t offset,
+                                             struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image2d_webgl(int32_t target,
+                                            int32_t level,
+                                            int32_t internalformat,
+                                            uint32_t width,
+                                            uint32_t height,
+                                            int32_t border,
+                                            int32_t format,
+                                            int32_t type_,
+                                            struct WebGLState *webgl,
+                                            struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image2d_canvas2d(int32_t target,
+                                               int32_t level,
+                                               int32_t internalformat,
+                                               uint32_t width,
+                                               uint32_t height,
+                                               int32_t border,
+                                               int32_t format,
+                                               int32_t type_,
+                                               struct CanvasRenderingContext2D *canvas,
+                                               struct WebGLState *state);
+
+void canvas_native_webgl2_tex_image2d_image_data(int32_t target,
+                                                 int32_t level,
+                                                 int32_t internalformat,
+                                                 uint32_t width,
+                                                 uint32_t height,
+                                                 int32_t border,
+                                                 int32_t format,
+                                                 int32_t type_,
+                                                 const struct ImageData *image_data,
+                                                 struct WebGLState *state);
+
 #endif /* CANVAS_C_H */