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

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

@@ -54,6 +54,11 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     tmpl->Set(
             ConvertToV8String(isolate, "beginOcclusionQuery"),
             v8::FunctionTemplate::New(isolate, &BeginOcclusionQuery));
@@ -74,6 +79,14 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
             ConvertToV8String(isolate, "drawIndirect"),
             v8::FunctionTemplate::New(isolate, &DrawIndirect));
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "multiDrawIndexedIndirect"),
+            v8::FunctionTemplate::New(isolate, &MultiDrawIndexedIndirect));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "multiDrawIndirect"),
+            v8::FunctionTemplate::New(isolate, &MultiDrawIndirect));
+
     tmpl->Set(
             ConvertToV8String(isolate, "end"),
             v8::FunctionTemplate::New(isolate, &End));
@@ -136,6 +149,27 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
 }
 
 
+void
+GPURenderPassEncoderImpl::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_render_pass_encoder_get_label(ptr->pass_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+
 void
 GPURenderPassEncoderImpl::BeginOcclusionQuery(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
@@ -229,7 +263,7 @@ void GPURenderPassEncoderImpl::DrawIndexed(const v8::FunctionCallbackInfo<v8::Va
         }
 
         auto indexCount = indexCountVal->Uint32Value(
-                                                     context).FromJust();
+                context).FromJust();
         canvas_native_webgpu_render_pass_encoder_draw_indexed(ptr->GetPass(),
                                                               indexCount,
                                                               instanceCount, firstIndex,
@@ -265,6 +299,36 @@ GPURenderPassEncoderImpl::DrawIndexedIndirect(const v8::FunctionCallbackInfo<v8:
     }
 
 
+}
+
+void
+GPURenderPassEncoderImpl::MultiDrawIndexedIndirect(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto indirectBufferVal = args[0];
+    auto indirectOffsetVal = args[1];
+    auto countVal = args[2];
+
+
+    auto indirectBufferType = GetNativeType(indirectBufferVal);
+
+    if (indirectBufferType == NativeType::GPUBuffer) {
+        auto indirectBuffer = GPUBufferImpl::GetPointer(indirectBufferVal.As<v8::Object>());
+        uint64_t offset = (uint64_t) indirectOffsetVal->NumberValue(context).FromJust();
+        uint32_t count = countVal->Uint32Value(context).FromJust();
+        canvas_native_webgpu_render_pass_encoder_multi_draw_indexed_indirect(ptr->GetPass(),
+                                                                             indirectBuffer->GetGPUBuffer(),
+                                                                             offset, count);
+    }
+
+
 }
 
 void
@@ -292,6 +356,35 @@ GPURenderPassEncoderImpl::DrawIndirect(const v8::FunctionCallbackInfo<v8::Value>
     }
 
 
+}
+
+void
+GPURenderPassEncoderImpl::MultiDrawIndirect(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto indirectBufferVal = args[0];
+    auto indirectOffsetVal = args[1];
+    auto countVal = args[2];
+
+
+    auto indirectBufferType = GetNativeType(indirectBufferVal);
+
+    if (indirectBufferType == NativeType::GPUBuffer) {
+        auto indirectBuffer = GPUBufferImpl::GetPointer(indirectBufferVal.As<v8::Object>());
+        uint64_t offset = (uint64_t) indirectOffsetVal->NumberValue(context).FromJust();
+        uint32_t count = countVal->Uint32Value(context).FromJust();
+        canvas_native_webgpu_render_pass_encoder_multi_draw_indirect(ptr->GetPass(),
+                                                                     indirectBuffer->GetGPUBuffer(),
+                                                                     offset, count);
+    }
+
+
 }
 
 void GPURenderPassEncoderImpl::End(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -328,7 +421,7 @@ void GPURenderPassEncoderImpl::ExecuteBundles(const v8::FunctionCallbackInfo<v8:
         std::vector<const CanvasGPURenderBundle *> bundles;
         for (int i = 0; i < len; i++) {
             v8::Local<v8::Value> bundleVal;
-            bundlesArray->Get(context, i).ToLocal(&bundlesVal);
+            bundlesArray->Get(context, i).ToLocal(&bundleVal);
             auto type = GetNativeType(bundleVal);
             if (type == NativeType::GPURenderBundle) {
                 auto bundle = GPURenderBundleImpl::GetPointer(bundleVal.As<v8::Object>());
@@ -402,30 +495,34 @@ void GPURenderPassEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8::V
     auto dynamicOffsetsStart = args[3];
     auto dynamicOffsetsLength = args[4];
 
+    const CanvasGPUBindGroup *bindGroup = nullptr;
+
     auto type = GetNativeType(bindGroupVal);
 
+    auto index = indexVal->Uint32Value(context).FromJust();
+
     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_render_pass_encoder_set_bind_group(ptr->GetPass(), index,
-                                                                    bindgroup->GetBindGroup(),
-                                                                    static_cast<const uint32_t *>(static_cast<void *>(data)),
-                                                                    size, start, offset_length);
-        } else {
-            canvas_native_webgpu_render_pass_encoder_set_bind_group(ptr->GetPass(), index,
-                                                                    bindgroup->GetBindGroup(),
-                                                                    nullptr, 0, 0, 0);
-        }
+        auto group = GPUBindGroupImpl::GetPointer(bindGroupVal.As<v8::Object>());
+        bindGroup = group->GetBindGroup();
+    }
+
+    if (dynamicOffsets->IsUint32Array()) {
+        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_render_pass_encoder_set_bind_group(ptr->GetPass(), index,
+                                                                bindGroup,
+                                                                static_cast<const uint32_t *>(static_cast<void *>(data)),
+                                                                size, start, offset_length);
+    } else {
+        canvas_native_webgpu_render_pass_encoder_set_bind_group(ptr->GetPass(), index,
+                                                                bindGroup,
+                                                                nullptr, 0, 0, 0);
     }
 }
 
@@ -446,7 +543,7 @@ void GPURenderPassEncoderImpl::SetIndexBuffer(const v8::FunctionCallbackInfo<v8:
 
     auto type = GetNativeType(bufferVal);
 
-    if (type == NativeType::GPURenderBundleEncoder) {
+    if (type == NativeType::GPUBuffer) {
         auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
         auto indexFormat = ConvertFromV8String(isolate, indexFormatVal);
         if (offsetVal->IsNumber()) {
@@ -502,7 +599,7 @@ void GPURenderPassEncoderImpl::SetPipeline(const v8::FunctionCallbackInfo<v8::Va
     }
 
     auto pipelineVal = args[0];
-    if(GetNativeType(pipelineVal) == NativeType::GPURenderPipeline){
+    if (GetNativeType(pipelineVal) == NativeType::GPURenderPipeline) {
         auto pipeline = GPURenderPipelineImpl::GetPointer(pipelineVal.As<v8::Object>());
         canvas_native_webgpu_render_pass_encoder_set_pipeline(ptr->GetPass(),
                                                               pipeline->GetGPUPipeline());
@@ -565,13 +662,12 @@ void GPURenderPassEncoderImpl::SetVertexBuffer(const v8::FunctionCallbackInfo<v8
     int64_t size = -1;
     auto offsetVal = args[2];
     auto sizeVal = args[3];
+    auto type = GetNativeType(bufferVal);
+    auto isolate = args.GetIsolate();
+    if (type == NativeType::GPUBuffer) {
+        auto context = isolate->GetCurrentContext();
+        auto slot = slotVal->ToUint32(context).ToLocalChecked();
 
-    if (slotVal->IsUint32() && bufferVal->IsObject()) {
-        auto slot = slotVal.As<v8::Uint32>()->Value();
-        if (GetNativeType(bufferVal) != NativeType::GPUBuffer) {
-            // todo throw ??
-            return;
-        }
 
         auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
 
@@ -583,7 +679,7 @@ void GPURenderPassEncoderImpl::SetVertexBuffer(const v8::FunctionCallbackInfo<v8
             size = (int64_t) sizeVal.As<v8::Number>()->Value();
         }
 
-        canvas_native_webgpu_render_pass_encoder_set_vertex_buffer(ptr->GetPass(), slot,
+        canvas_native_webgpu_render_pass_encoder_set_vertex_buffer(ptr->GetPass(), slot->Value(),
                                                                    buffer->GetGPUBuffer(), offset,
                                                                    size);
 
@@ -596,29 +692,32 @@ void GPURenderPassEncoderImpl::SetViewport(const v8::FunctionCallbackInfo<v8::Va
         return;
     }
 
-    auto x = args[0];
-    auto y = args[1];
-    auto width = args[2];
-    auto height = args[3];
+    auto xVal = args[0];
+    auto yVal = args[1];
+    auto widthVal = args[2];
+    auto heightVal = args[3];
 
-    auto minDepth = args[4];
-    auto maxDepth = args[5];
+    auto minDepthVal = args[4];
+    auto maxDepthVal = args[5];
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
-    canvas_native_webgpu_render_pass_encoder_set_viewport(ptr->GetPass(),
-                                                          (float) x->NumberValue(
-                                                                  context).FromJust(),
-                                                          (float) y->NumberValue(
-                                                                  context).FromJust(),
-                                                          (float) width->NumberValue(
-                                                                  context).FromJust(),
-                                                          (float) height->NumberValue(
-                                                                  context).FromJust(),
-                                                          (float) minDepth->NumberValue(
-                                                                  context).FromJust(),
-                                                          (float) maxDepth->NumberValue(
-                                                                  context).FromJust());
+    
+    
+   auto x = (float) xVal->NumberValue(
+                                   context).FromJust();
+                                                          auto y = (float) yVal->NumberValue(
+                                                                                          context).FromJust();
+                                                          auto width = (float) widthVal->NumberValue(
+                                                                                                  context).FromJust();
+                                                          auto height = (float) heightVal->NumberValue(
+                                                                                                    context).FromJust();
+    
+                                                          auto minDepth = (float) minDepthVal->NumberValue(
+                                                                                                        context).FromJust();
+                                                          auto maxDepth = (float) maxDepthVal->NumberValue(
+                                                                                                        context).FromJust();
+
+    canvas_native_webgpu_render_pass_encoder_set_viewport(ptr->GetPass(),x,y,width,height, minDepth, maxDepth);
 
 }

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

@@ -38,6 +38,9 @@ public:
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void BeginOcclusionQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void Draw(const v8::FunctionCallbackInfo<v8::Value> &args);
@@ -48,6 +51,10 @@ public:
 
     static void DrawIndirect(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void MultiDrawIndexedIndirect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void MultiDrawIndirect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void End(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void EndOcclusionQuery(const v8::FunctionCallbackInfo<v8::Value> &args);

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

@@ -48,6 +48,10 @@ v8::Local<v8::FunctionTemplate> GPURenderPipelineImpl::GetCtor(v8::Isolate *isol
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
 
     tmpl->Set(
             ConvertToV8String(isolate, "getBindGroupLayout"),
@@ -82,3 +86,24 @@ void GPURenderPipelineImpl::GetBindGroupLayout(const v8::FunctionCallbackInfo<v8
     args.GetReturnValue().SetUndefined();
 }
 
+
+void
+GPURenderPipelineImpl::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_render_pipeline_get_label(ptr->pipeline_);
+        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/GPURenderPipelineImpl.h

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

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

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

@@ -9,7 +9,7 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class GPUSamplerImpl: ObjectWrapperImpl {
+class GPUSamplerImpl : ObjectWrapperImpl {
 public:
     explicit GPUSamplerImpl(const CanvasGPUSampler *sampler);
 
@@ -36,6 +36,9 @@ public:
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 
 private:
     const CanvasGPUSampler *sampler_;

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

@@ -47,10 +47,34 @@ v8::Local<v8::FunctionTemplate> GPUShaderModuleImpl::GetCtor(v8::Isolate *isolat
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
 
     cache->GPUShaderModuleTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
 
+void
+GPUShaderModuleImpl::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_shader_module_get_label(ptr->shaderModule_);
+        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/GPUShaderModuleImpl.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 CanvasGPUShaderModule *shaderModule_;
 };

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

@@ -5,6 +5,7 @@
 #include "GPUTextureImpl.h"
 #include "Caches.h"
 #include "GPUTextureViewImpl.h"
+#include "GPULabel.h"
 
 GPUTextureImpl::GPUTextureImpl(const CanvasGPUTexture *texture) : texture_(texture) {}
 
@@ -47,6 +48,10 @@ v8::Local<v8::FunctionTemplate> GPUTextureImpl::GetCtor(v8::Isolate *isolate) {
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
 
     tmpl->Set(
             ConvertToV8String(isolate, "destroy"),
@@ -107,6 +112,27 @@ v8::Local<v8::FunctionTemplate> GPUTextureImpl::GetCtor(v8::Isolate *isolate) {
     return ctorTmpl;
 }
 
+
+void
+GPUTextureImpl::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_texture_get_label(ptr->texture_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
 void
 GPUTextureImpl::GetDimension(v8::Local<v8::Name> name,
                              const v8::PropertyCallbackInfo<v8::Value> &info) {
@@ -249,6 +275,7 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
             aspect, 0, -1, 0, -1
     };
 
+    GPULabel label;
 
     if (descVal->IsObject()) {
         descriptor = new CanvasCreateTextureViewDescriptor{};
@@ -269,7 +296,6 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
         }
 
 
-
         v8::Local<v8::Value> arrayLayerCountVal;
         if (descObj->Get(context, ConvertToV8String(isolate, "arrayLayerCount")).ToLocal(
                 &arrayLayerCountVal) && arrayLayerCountVal->IsInt32()) {
@@ -297,16 +323,15 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
         descriptor->range = &range;
 
 
-
         v8::Local<v8::Value> formatVal;
         descObj->Get(context, ConvertToV8String(isolate, "format")).ToLocal(&formatVal);
         auto formatStr = ConvertFromV8String(isolate, formatVal);
 
-        descriptor->format = CanvasOptionalGPUTextureFormat {
-           CanvasOptionalGPUTextureFormatNone
+        descriptor->format = CanvasOptionalGPUTextureFormat{
+                CanvasOptionalGPUTextureFormatNone
         };
 
-        if (!formatStr.empty()){
+        if (!formatStr.empty()) {
             auto format = canvas_native_webgpu_enum_string_to_gpu_texture(formatStr.c_str());
             descriptor->format = format;
         }
@@ -317,9 +342,9 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
         v8::Local<v8::Value> labelVal;
         descObj->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
 
-        if (!labelVal.IsEmpty() && labelVal->IsString()) {
-            descriptor->label = *v8::String::Utf8Value(isolate, labelVal);
-        }
+        label = GPULabel(isolate, labelVal);
+
+        descriptor->label = *label;
 
         v8::Local<v8::Value> dimensionVal;
         if (descObj->Get(context, ConvertToV8String(isolate, "dimension")).ToLocal(&dimensionVal)) {
@@ -347,6 +372,7 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     if (descriptor != nullptr) {
         delete descriptor;
+        descriptor = nullptr;
     }
 
     if (view != nullptr) {

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

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

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

@@ -46,8 +46,34 @@ v8::Local<v8::FunctionTemplate> GPUTextureViewImpl::GetCtor(v8::Isolate *isolate
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
 
     cache->GPUTextureViewTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
+
+
+void
+GPUTextureViewImpl::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_texture_view_get_label(ptr->view_);
+        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/GPUTextureViewImpl.h

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