@nativescript/canvas 2.0.0-webgpu.2 → 2.0.0-webgpu.21

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);
@@ -24,14 +25,14 @@ public:
 
     static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUBufferImpl *adapter) {
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUBufferImpl *buffer) {
         auto context = isolate->GetCurrentContext();
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUBufferImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUBuffer);
-        object->SetAlignedPointerInInternalField(0, adapter);
-        adapter->BindFinalizer(isolate, object);
+        SetNativeType(buffer, NativeType::GPUBuffer);
+        object->SetAlignedPointerInInternalField(0, buffer);
+        buffer->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
@@ -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/GPUCanvasContextImpl.h

@@ -31,7 +31,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUCanvasContextImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUCanvasContext);
+        SetNativeType(ctx, NativeType::GPUCanvasContext);
         object->SetAlignedPointerInInternalField(0, ctx);
         ctx->BindFinalizer(isolate, object);
         return scope.Escape(object);

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() {
@@ -22,7 +23,7 @@ void GPUCommandBufferImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUCommandBuffer"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUCommandBuffer"), func).FromJust();
 }
 
 GPUCommandBufferImpl *GPUCommandBufferImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -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

@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUCommandBufferImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUCommandBuffer);
+        SetNativeType(commandBuffer, NativeType::GPUCommandBuffer);
         object->SetAlignedPointerInInternalField(0, commandBuffer);
         commandBuffer->BindFinalizer(isolate, object);
         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);
 
@@ -232,15 +255,10 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
     if (!descVal->IsNullOrUndefined() && descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
 
-
         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;
@@ -260,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;
-         
-            auto viewPtr = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
-            view = viewPtr->GetTextureView();
-            
-            const CanvasGPUTextureView *resolve_target = 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();
+                }
+            }
+
+
+            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;
-
-            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;
-                    }
-                }
-            }
-    
-         
             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;
-                    }
-                }
-            }
+            colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                            "loadOp")).ToLocal(&loadVal);
+
+            colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                            "storeOp")).ToLocal(&storeVal);
+
+
+            CanvasLoadOp load = ParseCanvasLoadOp(isolate, loadVal);
+            CanvasStoreOp store = ParseCanvasStoreOp(isolate, storeVal);
+
 
             CanvasPassChannelColor channel{
                     load,
@@ -329,7 +328,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
 
             auto attachment = CanvasRenderPassColorAttachment{
                     view,
-                    resolve_target,
+                    resolveTarget,
                     channel
             };
 
@@ -381,20 +380,20 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &depthLoadOp);
 
             depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                CanvasOptionalLoadOpNone
+                    CanvasOptionalLoadOpNone
             };
 
             if (!depthLoadOp.IsEmpty() && depthLoadOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, depthLoadOp);
                 if (value == "load") {
                     depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpLoad
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpLoad
                     };
                 } else if (value == "clear") {
                     depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpClear
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpClear
                     };
                 }
             }
@@ -406,20 +405,20 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &depthStoreOp);
 
             depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                CanvasOptionalStoreOpNone
+                    CanvasOptionalStoreOpNone
             };
 
             if (!depthStoreOp.IsEmpty() && depthStoreOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, depthStoreOp);
                 if (value == "store") {
                     depthStencilAttachment->depth_store_op = depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpStore
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpStore
                     };
                 } else if (value == "discard") {
                     depthStencilAttachment->depth_store_op = depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpDiscard
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpDiscard
                     };
                 }
             }
@@ -455,20 +454,20 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &stencilLoadOp);
 
             depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                CanvasOptionalLoadOpNone
+                    CanvasOptionalLoadOpNone
             };
 
             if (!stencilLoadOp.IsEmpty() && stencilLoadOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, stencilLoadOp);
                 if (value == "load") {
                     depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpLoad
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpLoad
                     };
                 } else if (value == "clear") {
                     depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpClear
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpClear
                     };
                 }
             }
@@ -480,20 +479,20 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &stencilStoreOp);
 
             depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                CanvasOptionalStoreOpNone
+                    CanvasOptionalStoreOpNone
             };
 
             if (!stencilStoreOp.IsEmpty() && stencilStoreOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, stencilStoreOp);
                 if (value == "store") {
                     depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpStore
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpStore
                     };
                 } else if (value == "discard") {
                     depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpDiscard
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpDiscard
                     };
                 }
             }
@@ -518,7 +517,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
         desc->Get(context, ConvertToV8String(isolate, "occlusionQuerySet")).ToLocal(
                 &occlusionQuerySetVal);
 
-        
+
         if (GetNativeType(occlusionQuerySetVal) == NativeType::GPUQuerySet) {
             auto occlusionQuerySet = GPUQuerySetImpl::GetPointer(
                     occlusionQuerySetVal.As<v8::Object>());
@@ -578,13 +577,14 @@ 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
         );
 
         if (depthStencilAttachment != nullptr) {
             delete depthStencilAttachment;
+            depthStencilAttachment = nullptr;
         }
 
 
@@ -1099,21 +1099,16 @@ void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &ar
     auto isolate = args.GetIsolate();
     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);
@@ -29,12 +30,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUCommandEncoderImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUCommandEncoder);
+        SetNativeType(encoder, NativeType::GPUCommandEncoder);
         object->SetAlignedPointerInInternalField(0, encoder);
         encoder->BindFinalizer(isolate, object);
         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);