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

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

@@ -47,7 +47,33 @@ v8::Local<v8::FunctionTemplate> GPUBindGroupLayoutImpl::GetCtor(v8::Isolate *iso
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     cache->GPUBindGroupLayoutTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+
+void
+GPUBindGroupLayoutImpl::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_layout_get_label(ptr->groupLayout_);
+        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/GPUBindGroupLayoutImpl.h

@@ -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 CanvasGPUBindGroupLayout *groupLayout_;
 };

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

@@ -75,6 +75,11 @@ v8::Local<v8::FunctionTemplate> GPUBufferImpl::GetCtor(v8::Isolate *isolate) {
             ConvertToV8String(isolate, "getMappedRange"),
             v8::FunctionTemplate::New(isolate, &GetMappedRange));
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
 
     cache->GPUBufferTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -127,12 +132,17 @@ void GPUBufferImpl::UnMap(const v8::FunctionCallbackInfo<v8::Value> &args) {
     canvas_native_webgpu_buffer_unmap(ptr->GetGPUBuffer());
 }
 
+struct MapAsyncData {
+    enum CanvasGPUErrorType type;
+    char* error;
+};
 
 void GPUBufferImpl::MapAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
     GPUBufferImpl *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
     }
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
     auto mode = args[0]->Int32Value(context).ToChecked();
@@ -177,31 +187,34 @@ void GPUBufferImpl::MapAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
                     if (func->data == nullptr) {
                         callback->Resolve(context, v8::Undefined(isolate));
                     } else {
-                        char* error = static_cast<char*>(func->data);
+                        auto errorData = static_cast<MapAsyncData*>(func->data);
                         callback->Reject(context,
                                          v8::Exception::Error(
                                                  ConvertToV8String(
                                                          isolate,
-                                                         error)));
+                                                         errorData->error)));
                         canvas_native_string_destroy(
-                                error);
+                                errorData->error);
+                        delete errorData;
                         func->data = nullptr;
                     }
-                    delete static_cast<PromiseCallback *>(data);
                 }
+                delete static_cast<PromiseCallback *>(data);
             }
     };
     callback->prepare();
 
 
-    canvas_native_webgpu_buffer_map_async(ptr->GetGPUBuffer(), (GPUMapMode) mode, offset, size,
-                                          [](char *error, void *data) {
+    canvas_native_webgpu_buffer_map_async(ptr->GetGPUBuffer(), mode == 1 ? GPUMapMode::GPUMapModeRead : GPUMapMode::GPUMapModeWrite, offset, size,
+                                          [](enum CanvasGPUErrorType type, char *error, void *data) {
                                               if (data != nullptr) {
                                                   auto async_data = static_cast<PromiseCallback *>(data);
                                                   auto inner = async_data->inner_.get();
                                                   if (inner != nullptr) {
                                                       if(error != nullptr){
-                                                          inner->data = error;
+                                                          inner->data = new MapAsyncData {
+                                                              type, error
+                                                          };
                                                       }
                                                       async_data->execute(true);
                                                   }
@@ -241,3 +254,24 @@ void GPUBufferImpl::GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &ar
         args.GetReturnValue().Set(ab);
     }
 }
+
+
+void
+GPUBufferImpl::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_buffer_get_label(ptr->buffer_);
+        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/GPUBufferImpl.h

@@ -8,6 +8,7 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
+
 class GPUBufferImpl : ObjectWrapperImpl {
 public:
     explicit GPUBufferImpl(const CanvasGPUBuffer *buffer);
@@ -50,6 +51,9 @@ public:
 
     static void GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 
 private:
     const CanvasGPUBuffer *buffer_;

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

@@ -189,7 +189,7 @@ void GPUCanvasContextImpl::Configure(const v8::FunctionCallbackInfo<v8::Value> &
 
     v8::Local<v8::Value> sizeValue;
     options->Get(context, ConvertToV8String(isolate, "size")).ToLocal(
-            &usageValue);
+            &sizeValue);
 
     CanvasExtent3d size = ParseExtent3d(isolate, sizeValue);
 
@@ -207,7 +207,7 @@ void GPUCanvasContextImpl::UnConfigure(const v8::FunctionCallbackInfo<v8::Value>
         return;
     }
 
-    //  canvas_native_webgpu_context_unconfigure(ptr->GetContext());
+    canvas_native_webgpu_context_unconfigure(ptr->GetContext());
 
 }
 
@@ -224,9 +224,15 @@ void GPUCanvasContextImpl::GetCurrentTexture(const v8::FunctionCallbackInfo<v8::
     auto texture = canvas_native_webgpu_context_get_current_texture(ctx);
 
     if (texture != nullptr) {
-        auto textureImpl = new GPUTextureImpl(texture);
-        auto ret = GPUTextureImpl::NewInstance(isolate, textureImpl);
-        args.GetReturnValue().Set(ret);
+        auto status = canvas_native_webgpu_texture_get_status(texture);
+        if(status == SurfaceGetCurrentTextureStatusSuccess){
+            auto textureImpl = new GPUTextureImpl(texture);
+            auto ret = GPUTextureImpl::NewInstance(isolate, textureImpl);
+            args.GetReturnValue().Set(ret);
+        }else {
+            canvas_native_webgpu_texture_release(texture);
+            args.GetReturnValue().SetNull();
+        }
         return;
     }
 

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

@@ -5,7 +5,8 @@
 #include "GPUCommandBufferImpl.h"
 #include "Caches.h"
 
-GPUCommandBufferImpl::GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer) : commandBuffer_(
+GPUCommandBufferImpl::GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer)
+        : commandBuffer_(
         commandBuffer) {}
 
 const CanvasGPUCommandBuffer *GPUCommandBufferImpl::GetGPUCommandBuffer() {
@@ -47,8 +48,34 @@ v8::Local<v8::FunctionTemplate> GPUCommandBufferImpl::GetCtor(v8::Isolate *isola
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
 
     cache->GPUCommandBufferTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+
+void
+GPUCommandBufferImpl::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_command_buffer_get_label(ptr->commandBuffer_);
+        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/GPUCommandBufferImpl.h

@@ -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 CanvasGPUCommandBuffer *commandBuffer_;
 };

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

@@ -11,6 +11,7 @@
 #include "GPURenderPassEncoderImpl.h"
 #include "GPUCommandBufferImpl.h"
 #include "GPUTextureImpl.h"
+#include "GPULabel.h"
 
 GPUCommandEncoderImpl::GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *encoder) : encoder_(
         encoder) {}
@@ -53,6 +54,10 @@ v8::Local<v8::FunctionTemplate> GPUCommandEncoderImpl::GetCtor(v8::Isolate *isol
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
 
     tmpl->Set(
             ConvertToV8String(isolate, "beginComputePass"),
@@ -112,6 +117,26 @@ v8::Local<v8::FunctionTemplate> GPUCommandEncoderImpl::GetCtor(v8::Isolate *isol
     return ctorTmpl;
 }
 
+void
+GPUCommandEncoderImpl::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_command_encoder_get_label(ptr->encoder_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
 
 void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto ptr = GetPointer(args.This());
@@ -133,32 +158,28 @@ void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::
         v8::Local<v8::Value> labelVal;
         desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
 
-        char *label = nullptr;
-
-        if (!labelVal.IsEmpty() && labelVal->IsString()) {
-            label = *v8::String::Utf8Value(isolate, labelVal);
-        }
+        auto label = GPULabel(isolate, labelVal);
 
         const CanvasGPUQuerySet *querySet = nullptr;
+
         int32_t beginningOfPassWriteIndex = -1;
 
         int32_t endOfPassWriteIndex = -1;
 
 
         v8::Local<v8::Value> timestampWritesVal;
-        desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
-                &timestampWritesVal);
-
 
-        if (!timestampWritesVal.IsEmpty() && timestampWritesVal->IsObject()) {
+        auto success = desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
+                &timestampWritesVal);
+        if (success && timestampWritesVal->IsObject()) {
             auto timestampWrites = timestampWritesVal.As<v8::Object>();
 
             v8::Local<v8::Value> querySetVal;
-            timestampWrites->Get(context, ConvertToV8String(isolate, "querySet")).ToLocal(
+            success = timestampWrites->Get(context, ConvertToV8String(isolate, "querySet")).ToLocal(
                     &querySetVal);
 
 
-            if (!querySetVal.IsEmpty() && querySetVal->IsObject()) {
+            if (success && querySetVal->IsObject()) {
                 auto queryPtr = GPUQuerySetImpl::GetPointer(querySetVal.As<v8::Object>());
                 if (queryPtr != nullptr) {
                     querySet = queryPtr->GetQuerySet();
@@ -171,27 +192,29 @@ void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::
             v8::Local<v8::Value> endOfPassWriteIndexVal;
 
 
-            timestampWrites->Get(context,
-                                 ConvertToV8String(isolate, "beginningOfPassWriteIndex")).ToLocal(
+            success = timestampWrites->Get(context,
+                                           ConvertToV8String(isolate,
+                                                             "beginningOfPassWriteIndex")).ToLocal(
                     &beginningOfPassWriteIndexVal);
 
-            timestampWrites->Get(context,
-                                 ConvertToV8String(isolate, "endOfPassWriteIndex")).ToLocal(
-                    &endOfPassWriteIndexVal);
-
-
-            if (beginningOfPassWriteIndexVal->IsInt32()) {
+            if (success && beginningOfPassWriteIndexVal->IsInt32()) {
                 beginningOfPassWriteIndex = beginningOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
 
-            if (endOfPassWriteIndexVal->IsInt32()) {
+            success = timestampWrites->Get(context,
+                                           ConvertToV8String(isolate,
+                                                             "endOfPassWriteIndex")).ToLocal(
+                    &endOfPassWriteIndexVal);
+
+
+            if (success && endOfPassWriteIndexVal->IsInt32()) {
                 endOfPassWriteIndex = endOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
         }
 
 
         pass = canvas_native_webgpu_command_encoder_begin_compute_pass(ptr->GetEncoder(),
-                                                                       querySet, label,
+                                                                       querySet, *label,
                                                                        beginningOfPassWriteIndex,
                                                                        endOfPassWriteIndex);
 
@@ -235,11 +258,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
         v8::Local<v8::Value> labelVal;
         desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
 
-        char *label = nullptr;
-
-        if (!labelVal.IsEmpty() && labelVal->IsString()) {
-            label = *v8::String::Utf8Value(isolate, labelVal);
-        }
+        auto label = GPULabel(isolate, labelVal);
 
 
         v8::Local<v8::Value> colorAttachmentsVal;
@@ -259,65 +278,46 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
 
             auto clearValue = ParseColor(isolate, clearValueVal);
 
+            const CanvasGPUTextureView *view = nullptr;
+
             v8::Local<v8::Value> viewVal;
-            colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                            "view")).ToLocal(&viewVal);
 
-            const CanvasGPUTextureView *view = nullptr;
+            if (colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                                "view")).ToLocal(&viewVal)) {
+                auto type = GetNativeType(viewVal);
+                if (type == NativeType::GPUTextureView) {
+                    auto viewPtr = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
+                    view = viewPtr->GetTextureView();
+                }
+            }
 
-            auto viewPtr = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
-            view = viewPtr->GetTextureView();
 
-            const CanvasGPUTextureView *resolve_target = nullptr;
+            const CanvasGPUTextureView *resolveTarget = nullptr;
 
-            v8::Local<v8::Value> resolve_target_val;
+            v8::Local<v8::Value> resolveTargetVal;
 
             colorAttachment->Get(context, ConvertToV8String(isolate, "resolveTarget")).ToLocal(
-                    &resolve_target_val);
+                    &resolveTargetVal);
 
-            auto resolve_target_type = GetNativeType(resolve_target_val);
+            auto resolve_target_type = GetNativeType(resolveTargetVal);
 
             if (resolve_target_type == NativeType::GPUTextureView) {
-                auto res = GPUTextureViewImpl::GetPointer(resolve_target_val.As<v8::Object>());
-                resolve_target = res->GetTextureView();
+                auto res = GPUTextureViewImpl::GetPointer(resolveTargetVal.As<v8::Object>());
+                resolveTarget = res->GetTextureView();
             }
 
-            // default
-            CanvasLoadOp load = CanvasLoadOp::CanvasLoadOpClear;
-            CanvasStoreOp store = CanvasStoreOp::CanvasStoreOpStore;
             v8::Local<v8::Value> loadVal;
+            v8::Local<v8::Value> storeVal;
+            colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                            "loadOp")).ToLocal(&loadVal);
 
-            if (colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                                "loadOp")).ToLocal(&loadVal)) {
-                if (loadVal->IsUint32()) {
-                    load = (CanvasLoadOp) loadVal->Uint32Value(
-                            context).ToChecked();
-                } else if (loadVal->IsString()) {
-                    auto val = ConvertFromV8String(isolate, loadVal);
-                    if (val == "clear") {
-                        load = CanvasLoadOp::CanvasLoadOpClear;
-                    } else if (val == "load") {
-                        load = CanvasLoadOp::CanvasLoadOpLoad;
-                    }
-                }
-            }
+            colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                            "storeOp")).ToLocal(&storeVal);
 
 
-            v8::Local<v8::Value> storeVal;
-            if (colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                                "storeOp")).ToLocal(&storeVal)) {
-                if (storeVal->IsUint32()) {
-                    store = (CanvasStoreOp) storeVal->Uint32Value(
-                            context).ToChecked();
-                } else if (storeVal->IsString()) {
-                    auto val = ConvertFromV8String(isolate, storeVal);
-                    if (val == "discard") {
-                        store = CanvasStoreOp::CanvasStoreOpDiscard;
-                    } else if (val == "store") {
-                        store = CanvasStoreOp::CanvasStoreOpStore;
-                    }
-                }
-            }
+            CanvasLoadOp load = ParseCanvasLoadOp(isolate, loadVal);
+            CanvasStoreOp store = ParseCanvasStoreOp(isolate, storeVal);
+
 
             CanvasPassChannelColor channel{
                     load,
@@ -328,7 +328,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
 
             auto attachment = CanvasRenderPassColorAttachment{
                     view,
-                    resolve_target,
+                    resolveTarget,
                     channel
             };
 
@@ -577,7 +577,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
 
 
         pass = canvas_native_webgpu_command_encoder_begin_render_pass(
-                ptr->GetEncoder(), label, colorAttachments_.data(), colorAttachments_.size(),
+                ptr->GetEncoder(), *label, colorAttachments_.data(), colorAttachments_.size(),
                 depthStencilAttachment, occlusion_query_set,
                 querySet, beginningOfPassWriteIndex, endOfPassWriteIndex
         );
@@ -1100,19 +1100,15 @@ void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &ar
     auto context = isolate->GetCurrentContext();
 
     auto descVal = args[0];
-    std::string label;
-    bool didSet = false;
+    GPULabel label;
     if (descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
         v8::Local<v8::Value> labelVal;
-        didSet = desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
-        if (didSet && labelVal->IsString()) {
-            label = ConvertFromV8String(isolate, labelVal);
-        }
+        desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
+        label = GPULabel(isolate, labelVal);
     }
 
-    auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(),
-                                                             didSet ? label.c_str() : nullptr);
+    auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(), *label);
 
     if (value != nullptr) {
         auto ret = GPUCommandBufferImpl::NewInstance(isolate, new GPUCommandBufferImpl(value));

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

@@ -8,6 +8,7 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 #include "GPUUtils.h"
+
 class GPUCommandEncoderImpl : ObjectWrapperImpl {
 public:
     explicit GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *encoder);
@@ -35,6 +36,9 @@ public:
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void BeginComputePass(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void BeginRenderPass(const v8::FunctionCallbackInfo<v8::Value> &args);

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

@@ -26,7 +26,8 @@ void GPUComputePassEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Iso
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUComputePassEncoder"), func).FromJust();
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUComputePassEncoder"),
+                      func).FromJust();
 }
 
 GPUComputePassEncoderImpl *
@@ -52,6 +53,11 @@ v8::Local<v8::FunctionTemplate> GPUComputePassEncoderImpl::GetCtor(v8::Isolate *
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     tmpl->Set(
             ConvertToV8String(isolate, "dispatchWorkgroups"),
             v8::FunctionTemplate::New(isolate, &DispatchWorkgroups));
@@ -86,10 +92,32 @@ v8::Local<v8::FunctionTemplate> GPUComputePassEncoderImpl::GetCtor(v8::Isolate *
 
 
     cache->GPUComputePassEncoderTmpl =
-            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>
+                    (isolate, ctorTmpl);
     return ctorTmpl;
 }
 
+void
+GPUComputePassEncoderImpl::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_compute_pass_encoder_get_label(ptr->computePass_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+
 void
 GPUComputePassEncoderImpl::DispatchWorkgroups(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
@@ -216,30 +244,35 @@ void GPUComputePassEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8::
     auto dynamicOffsetsStart = args[3];
     auto dynamicOffsetsLength = args[4];
 
+    const CanvasGPUBindGroup *bindGroup = nullptr;
+
     auto type = GetNativeType(bindGroupVal);
 
     if (type == NativeType::GPUBindGroup) {
-        auto index = indexVal->Uint32Value(context).FromJust();
-        auto bindgroup = GPUBindGroupImpl::GetPointer(bindGroupVal.As<v8::Object>());
-
-        if (dynamicOffsets->IsUint8Array()) {
-            auto buf = dynamicOffsets.As<v8::Uint32Array>();
-            auto buffer = buf->Buffer();
-            auto store = buffer->GetBackingStore();
-            auto offset = buf->ByteOffset();
-            auto data = static_cast<uint8_t *>(buffer->GetBackingStore()->Data()) + offset;
-            auto size = buf->Length();
-            auto start = (size_t) dynamicOffsetsStart->NumberValue(context).FromJust();
-            auto offset_length = (size_t) dynamicOffsetsLength->NumberValue(context).FromJust();
-            canvas_native_webgpu_compute_pass_encoder_set_bind_group(ptr->GetComputePass(), index,
-                                                                     bindgroup->GetBindGroup(),
-                                                                     static_cast<const uint32_t *>(static_cast<void *>(data)),
-                                                                     size, start, offset_length);
-        } else {
-            canvas_native_webgpu_compute_pass_encoder_set_bind_group(ptr->GetComputePass(), index,
-                                                                     bindgroup->GetBindGroup(),
-                                                                     nullptr, 0, 0, 0);
-        }
+        auto group = GPUBindGroupImpl::GetPointer(bindGroupVal.As<v8::Object>());
+        bindGroup = group->GetBindGroup();
+    }
+
+    auto index = indexVal->Uint32Value(context).FromJust();
+
+
+    if (dynamicOffsets->IsUint8Array()) {
+        auto buf = dynamicOffsets.As<v8::Uint32Array>();
+        auto buffer = buf->Buffer();
+        auto store = buffer->GetBackingStore();
+        auto offset = buf->ByteOffset();
+        auto data = static_cast<uint8_t *>(buffer->GetBackingStore()->Data()) + offset;
+        auto size = buf->Length();
+        auto start = (size_t) dynamicOffsetsStart->NumberValue(context).FromJust();
+        auto offset_length = (size_t) dynamicOffsetsLength->NumberValue(context).FromJust();
+        canvas_native_webgpu_compute_pass_encoder_set_bind_group(ptr->GetComputePass(), index,
+                                                                 bindGroup,
+                                                                 static_cast<const uint32_t *>(static_cast<void *>(data)),
+                                                                 size, start, offset_length);
+    } else {
+        canvas_native_webgpu_compute_pass_encoder_set_bind_group(ptr->GetComputePass(), index,
+                                                                 bindGroup,
+                                                                 nullptr, 0, 0, 0);
     }
 }
 

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

@@ -36,6 +36,9 @@ public:
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void DispatchWorkgroups(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void DispatchWorkgroupsIndirect(const v8::FunctionCallbackInfo<v8::Value> &args);