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

package/platforms/ios/src/cpp/ImageAssetImpl.h

@@ -19,11 +19,11 @@
 class ImageAssetImpl : ObjectWrapperImpl {
 public:
 
-    explicit ImageAssetImpl(ImageAsset *asset);
+    explicit ImageAssetImpl(const ImageAsset *asset);
 
     ~ImageAssetImpl();
 
-    ImageAsset *GetImageAsset();
+    const ImageAsset *GetImageAsset();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -61,11 +61,15 @@ public:
 
     static void FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void FromEncodedBytesSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromEncodedBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     /* static void SaveSync(const v8::FunctionCallbackInfo<v8::Value> &args);
 
      static void SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args);*/
 
 
 private:
-    ImageAsset *asset_;
+    const ImageAsset *asset_;
 };

package/platforms/ios/src/cpp/ImageBitmapImpl.cpp

@@ -5,10 +5,10 @@
 #include "ImageBitmapImpl.h"
 #include "Caches.h"
 
-ImageBitmapImpl::ImageBitmapImpl(ImageAsset* asset)
+ImageBitmapImpl::ImageBitmapImpl(const ImageAsset *asset)
         : bitmap_(asset) {}
 
-ImageBitmapImpl::~ImageBitmapImpl(){
+ImageBitmapImpl::~ImageBitmapImpl() {
     canvas_native_image_asset_release(bitmap_);
     this->bitmap_ = nullptr;
 }
@@ -26,6 +26,23 @@ void ImageBitmapImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isol
     canvasModule->Set(context, ConvertToV8String(isolate, "ImageBitmap"), func);
 }
 
+
+void ImageBitmapImpl::FromAsset(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto asset = args[0];
+    auto type = GetNativeType(asset);
+    auto isolate = args.GetIsolate();
+    if (type == NativeType::ImageAsset){
+        auto ptr = ImageAssetImpl::GetPointer(asset.As<v8::Object>());
+        auto ret = canvas_native_image_asset_reference(ptr->GetImageAsset());
+        auto bitmap = new ImageBitmapImpl(ret);
+        auto data = v8::External::New(isolate, bitmap);
+        auto object = ImageBitmapImpl::NewInstance(isolate, data);
+        args.GetReturnValue().Set(object);
+        return;
+    }
+    args.GetReturnValue().SetNull();
+}
+
 ImageBitmapImpl *ImageBitmapImpl::GetPointer(v8::Local<v8::Object> object) {
     auto ptr = object->GetAlignedPointerFromInternalField(0);
     if (ptr == nullptr) {
@@ -45,7 +62,10 @@ v8::Local<v8::FunctionTemplate> ImageBitmapImpl::GetCtor(v8::Isolate *isolate) {
     ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
     ctorTmpl->SetClassName(ConvertToV8String(isolate, "ImageBitmap"));
 
+    ctorTmpl->Set(ConvertToV8String(isolate, "fromAsset"), v8::FunctionTemplate::New(isolate, FromAsset));
+
     auto tmpl = ctorTmpl->InstanceTemplate();
+
     tmpl->SetInternalFieldCount(2);
     tmpl->SetAccessor(
             ConvertToV8String(isolate, "width"), GetWidth);
@@ -56,6 +76,13 @@ v8::Local<v8::FunctionTemplate> ImageBitmapImpl::GetCtor(v8::Isolate *isolate) {
     tmpl->Set(
             ConvertToV8String(isolate, "close"), v8::FunctionTemplate::New(isolate, Close));
 
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "__addr"),
+            GetAddr);
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "__getRef"),
+            v8::FunctionTemplate::New(isolate, GetReference));
 
     cache->ImageBitmapTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -93,6 +120,8 @@ void ImageBitmapImpl::Close(const v8::FunctionCallbackInfo<v8::Value> &args) {
         return;
     }
 
+    canvas_native_image_asset_close(ptr->GetImageAsset());
+
     ptr->closed_ = true;
 }
 
@@ -184,6 +213,34 @@ ImageBitmapImpl::HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value>
     return ret;
 }
 
-ImageAsset* ImageBitmapImpl::GetImageAsset() {
+
+void
+ImageBitmapImpl::GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto ret = std::to_string(canvas_native_image_asset_get_addr(ptr->GetImageAsset()));
+        info.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
+void
+ImageBitmapImpl::GetReference(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        auto isolate = args.GetIsolate();
+        auto reference = canvas_native_image_asset_reference(ptr->GetImageAsset());
+        auto ret = std::to_string(canvas_native_image_asset_get_addr(reference));
+        args.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+        return;
+    }
+
+    args.GetReturnValue().SetEmptyString();
+}
+
+const ImageAsset *ImageBitmapImpl::GetImageAsset() {
     return this->bitmap_;
 }

package/platforms/ios/src/cpp/ImageBitmapImpl.h

@@ -21,7 +21,7 @@ struct Options {
 
 class ImageBitmapImpl : public ObjectWrapperImpl {
 public:
-    explicit ImageBitmapImpl(ImageAsset *asset);
+    explicit ImageBitmapImpl(const ImageAsset *asset);
 
     ~ImageBitmapImpl();
 
@@ -46,7 +46,7 @@ public:
 
     static Options HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value> &options);
 
-    ImageAsset *GetImageAsset();
+    const ImageAsset *GetImageAsset();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -60,9 +60,16 @@ public:
     static void GetHeight(v8::Local<v8::String> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
+    static void GetReference(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void Close(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void FromAsset(const v8::FunctionCallbackInfo<v8::Value> &args);
+
 private:
-    ImageAsset *bitmap_;
+    const ImageAsset *bitmap_;
     bool closed_ = false;
 };

package/platforms/ios/src/cpp/PromiseCallback.h

@@ -163,7 +163,7 @@ struct PromiseCallback {
         auto data = new PromiseCallback(this->inner_);
         ALooper_addFd(looper,
                       fd,
-                      ALOOPER_POLL_CALLBACK,
+                      0,
                       ALOOPER_EVENT_INPUT,
                       [](int fd, int events,
                          void *data) {
@@ -175,7 +175,6 @@ struct PromiseCallback {
                           return 0;
                       }, (void *) data);
 
-        ALooper_wake(looper);
         inner->isPrepared_ = true;
     }
 

package/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.cpp

@@ -630,7 +630,7 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
         }
 
         canvas_native_context_draw_points(
-                ptr->GetContext(), pointMode,
+                ptr->GetContext(), (int32_t)pointMode,
                 store.data(), store.size());
 
 
@@ -1110,7 +1110,6 @@ void CanvasRenderingContext2DImpl::SetTextAlign(v8::Local<v8::String> property,
 void CanvasRenderingContext2DImpl::GetTextBaseline(v8::Local<v8::String> property,
                                                    const v8::PropertyCallbackInfo<v8::Value> &info) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(info.This());
-    auto isolate = info.GetIsolate();
     if (ptr == nullptr) {
         info.GetReturnValue().Set(0);
         return;
@@ -1963,7 +1962,6 @@ CanvasRenderingContext2DImpl::DrawAtlas(const v8::FunctionCallbackInfo<v8::Value
         return;
     }
 
-    auto count = args.Length();
     auto value = args[0];
 
     if (value->IsNullOrUndefined() || !value->IsObject()) {
@@ -2968,8 +2966,6 @@ void
 CanvasRenderingContext2DImpl::Stroke(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::Path2D) {
@@ -3136,12 +3132,12 @@ CanvasRenderingContext2DImpl::~CanvasRenderingContext2DImpl() {
 }
 
 void CanvasRenderingContext2DImpl::UpdateInvalidateState() {
-    auto raf = this->GetRaf();
-    if (raf != nullptr) {
-        if (!canvas_native_raf_get_started(raf->GetRaf())) {
-            canvas_native_raf_start(raf->GetRaf());
-        }
-    }
+//    auto raf = this->GetRaf();
+//    if (raf != nullptr) {
+//        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+//            canvas_native_raf_start(raf->GetRaf());
+//        }
+//    }
 
     auto state = this->GetInvalidateState();
     this->SetInvalidateState((int) state | (int) InvalidateState::InvalidateStatePending);

package/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.h

@@ -636,7 +636,7 @@ public:
     static void DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
-    DrawImageDxDyAssetImpl(CanvasRenderingContext2DImpl *ptr, ImageAsset *asset, double dx,
+    DrawImageDxDyAssetImpl(CanvasRenderingContext2DImpl *ptr, const ImageAsset *asset, double dx,
                            double dy) {
         if (asset != nullptr) {
             canvas_native_context_draw_image_dx_dy_asset(
@@ -690,7 +690,7 @@ public:
         }
     }
 
-    static void DrawImageDxDyDwDhAssetImpl(CanvasRenderingContext2DImpl *ptr, ImageAsset *asset,
+    static void DrawImageDxDyDwDhAssetImpl(CanvasRenderingContext2DImpl *ptr, const ImageAsset *asset,
                                            double dx, double dy, double dw, double dh) {
 
 
@@ -783,7 +783,7 @@ public:
 
     static void
     DrawImageAssetImpl(CanvasRenderingContext2DImpl *ptr,
-                       ImageAsset *asset, double sx,
+                       const ImageAsset *asset, double sx,
                        double sy, double sw, double sh, double dx, double dy, double dw,
                        double dh) {
 

package/platforms/ios/src/cpp/canvas2d/Path2D.h

@@ -199,7 +199,7 @@ public:
                             double rotation,
                             double start_angle,
                             double end_angle,
-                            double anticlockwise) {
+                            bool anticlockwise) {
 
         canvas_native_path_ellipse(
                 receiver_obj,
@@ -222,7 +222,7 @@ public:
                             double rotation,
                             double start_angle,
                             double end_angle,
-                            double anticlockwise) {
+                            bool anticlockwise) {
         Path2D *ptr = GetPointer(receiver_obj);
         if (ptr == nullptr) {
             return;
@@ -362,9 +362,9 @@ public:
 
                 canvas_native_path_round_rect(
                         ptr->GetPath(),
-                        x, y,
-                        width,
-                        height, buf.data(),
+                        (float)x, (float)y,
+                        (float)width,
+                        (float)height, buf.data(),
                         buf.size());
 
             }

package/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp

@@ -4350,8 +4350,113 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
                     ptr->GetState()
             );
             return;
-        }
+        } else {
+            auto objectType = GetNativeType(value);
+
+            switch (objectType) {
+                case NativeType::ImageAsset: {
+                    auto image_asset = ImageAssetImpl::GetPointer(value.As<v8::Object>());
+
+                    if (image_asset !=
+                        nullptr) {
+
+                        canvas_native_webgl2_tex_image2d_image_asset(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_asset->GetImageAsset(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::ImageBitmap: {
+                    auto image_bitmap = ImageBitmapImpl::GetPointer(value.As<v8::Object>());
+
+                    if (image_bitmap !=
+                        nullptr) {
+                        canvas_native_webgl2_tex_image2d_image_asset(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_bitmap->GetImageAsset(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::CanvasRenderingContext2D: {
+                    auto canvas_2d = CanvasRenderingContext2DImpl::GetPointer(
+                            value.As<v8::Object>());
+
+                    if (canvas_2d != nullptr) {
+                        canvas_native_webgl2_tex_image2d_canvas2d(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                canvas_2d->GetContext(),
+                                ptr->GetState()
+                        );
+                    }
+
+                    return;
+                }
+                case NativeType::WebGLRenderingContextBase: {
+                    auto gl = WebGLRenderingContext::GetPointer(value.As<v8::Object>());
+
+                    if (gl != nullptr) {
+                        canvas_native_webgl2_tex_image2d_webgl(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                gl->GetState(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::ImageData: {
+                    auto image_data = ImageDataImpl::GetPointer(value.As<v8::Object>());
+                    if (image_data != nullptr) {
+                        canvas_native_webgl2_tex_image2d_image_data(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_data->GetImageData(),
+                                ptr->GetState()
+                        );
+                    }
 
+                }
+                default:
+                    break;
+            }
+        }
     }
 }
 

package/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.cpp

@@ -82,11 +82,11 @@ void WebGLRenderingContextBase::StopRaf() {
 
 void WebGLRenderingContextBase::UpdateInvalidateState() {
     auto raf = this->GetRaf();
-    if (raf != nullptr) {
-        if (!canvas_native_raf_get_started(raf->GetRaf())) {
-            canvas_native_raf_start(raf->GetRaf());
-        }
-    }
+//    if (raf != nullptr) {
+//        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+//            canvas_native_raf_start(raf->GetRaf());
+//        }
+//    }
     auto state = this->GetInvalidateState();
     this->SetInvalidateState(state | (int) InvalidateState::InvalidateStatePending);
 }
@@ -141,8 +141,8 @@ WebGLRenderingContextBase::~WebGLRenderingContextBase() {
     if (_raf != nullptr) {
         canvas_native_raf_stop(
                                _raf->GetRaf());
+        canvas_native_raf_release(_raf->GetRaf());
     }
-    canvas_native_raf_release(_raf->GetRaf());
     this->raf_ = nullptr;
     canvas_native_webgl_state_destroy(this->GetState());
     this->state_ = nullptr;

package/platforms/ios/src/cpp/webgpu/GPUAdapterImpl.cpp

@@ -4,7 +4,7 @@
 
 #include "GPUAdapterImpl.h"
 #include "Caches.h"
-
+#include "GPULabel.h"
 GPUAdapterImpl::GPUAdapterImpl(const CanvasGPUAdapter *adapter) : adapter_(adapter) {}
 
 const CanvasGPUAdapter *GPUAdapterImpl::GetGPUAdapter() {
@@ -61,7 +61,6 @@ v8::Local<v8::FunctionTemplate> GPUAdapterImpl::GetCtor(v8::Isolate *isolate) {
             GetLimits
     );
 
-
     tmpl->Set(
             ConvertToV8String(isolate, "requestAdapterInfo"),
             v8::FunctionTemplate::New(isolate, &RequestAdapterInfo));
@@ -90,19 +89,19 @@ GPUAdapterImpl::GetFeatures(v8::Local<v8::Name> name,
 
         auto len = canvas_native_string_buffer_get_length(features);
 
-        auto map = v8::Map::New(isolate);
+        auto set = v8::Set::New(isolate);
         for (int i = 0; i < len; ++i) {
             auto item = canvas_native_string_buffer_get_value_at(features, i);
             if (item != nullptr) {
-                auto keyValue = ConvertToV8OneByteString(isolate, (char *) item);
-                map->Set(context, keyValue, keyValue);
+                auto keyValue = ConvertToV8String(isolate, (char *) item);
+                set->Add(context, keyValue);
                 canvas_native_string_destroy(item);
             }
 
         }
         canvas_native_string_buffer_release(features);
 
-        info.GetReturnValue().Set(map);
+        info.GetReturnValue().Set(set);
 
         return;
     }
@@ -162,11 +161,14 @@ struct RequestData {
     char *error_;
     const CanvasGPUDevice *device_;
     char **required_features_data_;
+    size_t required_features_data_size;
 
     ~RequestData() {
         if (required_features_data_ != nullptr) {
-            delete[] required_features_data_;
-            required_features_data_ = nullptr;
+            for (size_t i = 0; i < required_features_data_size; ++i) {
+                    delete[] required_features_data_[i];
+                }
+                delete[] required_features_data_;
         }
 
         if (error_ != nullptr) {
@@ -190,7 +192,7 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
 
     auto func = cb.As<v8::Function>();
 
-    std::string label;
+    GPULabel label;
 
     std::vector<std::string> required_features_buf;
 
@@ -201,10 +203,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         v8::Local<v8::Value> labelValue;
         options->Get(context, ConvertToV8String(isolate, "label")).ToLocal(
                 &labelValue);
+        
+        label = GPULabel(isolate, labelValue);
 
-        if (!labelValue.IsEmpty() && labelValue->IsString()) {
-            label = ConvertFromV8String(isolate, labelValue);
-        }
 
         v8::Local<v8::Value> requiredFeaturesValue;
 
@@ -212,11 +213,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                 &requiredFeaturesValue);
 
 
-        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsSet()) {
-            v8::Local<v8::Set> requiredFeaturesSet = requiredFeaturesValue.As<v8::Set>();
-            v8::Local<v8::Array> requiredFeatures = requiredFeaturesSet->AsArray();
+        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsArray()) {
+            v8::Local<v8::Array> requiredFeatures = requiredFeaturesValue.As<v8::Array>();
             auto len = requiredFeatures->Length();
-
             for (int i = 0; i < len; i++) {
                 auto item = requiredFeatures->Get(context, i);
                 if (!item.IsEmpty()) {
@@ -245,10 +244,12 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
     size_t required_features_data_length = required_features_buf.size();
 
     if (required_features_data_length > 0) {
-        required_features_data = new char *[required_features_data_length + 1];
+        required_features_data = new char *[required_features_data_length];
 
         for (size_t i = 0; i < required_features_data_length; ++i) {
-            std::strcpy(required_features_data[i], required_features_buf[i].c_str());
+            required_features_data[i] = new char[required_features_buf[i].size() + 1];
+            auto src = required_features_buf[i].c_str();
+            std::strcpy(required_features_data[i], src);
         }
     }
 
@@ -297,7 +298,8 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                             callback->Call(context, context->Global(),
                                            1,
                                            args);  // ignore JS return value
-                            delete static_cast<AsyncCallback *>(data);
+                            
+                            
                         } else {
 
                             auto impl = new GPUDeviceImpl(requestData->device_);
@@ -311,14 +313,14 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                             callback->Call(context, context->Global(),
                                            2,
                                            args);  // ignore JS return value
-
-                            delete static_cast<AsyncCallback *>(data);
                         }
 
                         if (requestData != nullptr) {
                             delete requestData;
                             requestData = nullptr;
                         }
+
+                        delete static_cast<AsyncCallback *>(data);
                     }
                 }
             }
@@ -330,14 +332,15 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         inner->data = new RequestData{
                 nullptr,
                 nullptr,
-                required_features_data
+                required_features_data,
+                required_features_data_length
         };
     }
 
     callback->prepare();
 
     canvas_native_webgpu_adapter_request_device(ptr->GetGPUAdapter(),
-                                                label.empty() ? nullptr : label.c_str(),
+                                                *label,
                                                 required_features_data,
                                                 required_features_data_length,
                                                 limits,

package/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.cpp

@@ -13,7 +13,7 @@ const CanvasGPUBindGroup *GPUBindGroupImpl::GetBindGroup() {
 }
 
 
-void GPUBindGroupImpl::Init(v8::Local <v8::Object> canvasModule, v8::Isolate *isolate) {
+void GPUBindGroupImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
     v8::Locker locker(isolate);
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
@@ -25,7 +25,7 @@ void GPUBindGroupImpl::Init(v8::Local <v8::Object> canvasModule, v8::Isolate *is
     canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroup"), func).FromJust();
 }
 
-GPUBindGroupImpl *GPUBindGroupImpl::GetPointer(const v8::Local <v8::Object> &object) {
+GPUBindGroupImpl *GPUBindGroupImpl::GetPointer(const v8::Local<v8::Object> &object) {
     auto ptr = object->GetAlignedPointerFromInternalField(0);
     if (ptr == nullptr) {
         return nullptr;
@@ -33,21 +33,47 @@ GPUBindGroupImpl *GPUBindGroupImpl::GetPointer(const v8::Local <v8::Object> &obj
     return static_cast<GPUBindGroupImpl *>(ptr);
 }
 
-v8::Local <v8::FunctionTemplate> GPUBindGroupImpl::GetCtor(v8::Isolate *isolate) {
+v8::Local<v8::FunctionTemplate> GPUBindGroupImpl::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->GPUBindGroupTmpl.get();
     if (ctor != nullptr) {
         return ctor->Get(isolate);
     }
 
-    v8::Local <v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
     ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
     ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUBindGroup"));
 
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     cache->GPUBindGroupTmpl =
-            std::make_unique < v8::Persistent < v8::FunctionTemplate >> (isolate, ctorTmpl);
+            std::make_unique<v8::Persistent<v8::FunctionTemplate >>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+
+void
+GPUBindGroupImpl::GetLabel(v8::Local<v8::Name> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_bind_group_get_label(ptr->group_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}

package/platforms/ios/src/cpp/webgpu/GPUBindGroupImpl.h

@@ -11,7 +11,7 @@
 
 class GPUBindGroupImpl : ObjectWrapperImpl {
 public:
-    GPUBindGroupImpl(const CanvasGPUBindGroup *group);
+    explicit GPUBindGroupImpl(const CanvasGPUBindGroup *group);
 
     ~GPUBindGroupImpl() {
         canvas_native_webgpu_bind_group_release(this->GetBindGroup());
@@ -37,6 +37,9 @@ public:
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 private:
     const CanvasGPUBindGroup *group_;
 };