@nativescript/canvas 2.0.0-webgpu.0 → 2.0.0-webgpu.10

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

@@ -27,7 +27,8 @@ void GPURenderPassEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isol
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderPassEncoder"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderPassEncoder"),
+                      func).FromJust();
 }
 
 GPURenderPassEncoderImpl *
@@ -53,6 +54,10 @@ 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"),
@@ -66,7 +71,6 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
             ConvertToV8String(isolate, "drawIndexed"),
             v8::FunctionTemplate::New(isolate, &DrawIndexed));
 
-
     tmpl->Set(
             ConvertToV8String(isolate, "drawIndexedIndirect"),
             v8::FunctionTemplate::New(isolate, &DrawIndexedIndirect));
@@ -75,12 +79,10 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
             ConvertToV8String(isolate, "drawIndirect"),
             v8::FunctionTemplate::New(isolate, &DrawIndirect));
 
-
     tmpl->Set(
             ConvertToV8String(isolate, "end"),
             v8::FunctionTemplate::New(isolate, &End));
 
-
     tmpl->Set(
             ConvertToV8String(isolate, "endOcclusionQuery"),
             v8::FunctionTemplate::New(isolate, &EndOcclusionQuery));
@@ -139,6 +141,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());
@@ -173,7 +196,6 @@ void GPURenderPassEncoderImpl::Draw(const v8::FunctionCallbackInfo<v8::Value> &a
     if (vertexCountVal->IsUint32()) {
         auto vertexCount = vertexCountVal.As<v8::Uint32>()->Value();
 
-
         if (instanceCountVal->IsUint32()) {
             instanceCount = instanceCountVal.As<v8::Uint32>()->Value();
         }
@@ -209,12 +231,16 @@ void GPURenderPassEncoderImpl::DrawIndexed(const v8::FunctionCallbackInfo<v8::Va
 
 
     auto indexCountVal = args[0];
-    auto firstIndexVal = args[1];
-    auto baseVertexVal = args[2];
-    auto firstInstanceVal = args[3];
+    auto instanceCountVal = args[1];
+    auto firstIndexVal = args[2];
+    auto baseVertexVal = args[3];
+    auto firstInstanceVal = args[4];
 
     if (indexCountVal->IsUint32()) {
 
+        if (instanceCountVal->IsUint32()) {
+            instanceCount = instanceCountVal.As<v8::Uint32>()->Value();
+        }
 
         if (firstIndexVal->IsUint32()) {
             firstIndex = firstIndexVal.As<v8::Uint32>()->Value();
@@ -228,9 +254,10 @@ void GPURenderPassEncoderImpl::DrawIndexed(const v8::FunctionCallbackInfo<v8::Va
             firstInstance = firstInstanceVal.As<v8::Uint32>()->Value();
         }
 
+        auto indexCount = indexCountVal->Uint32Value(
+                context).FromJust();
         canvas_native_webgpu_render_pass_encoder_draw_indexed(ptr->GetPass(),
-                                                              indexCountVal->Uint32Value(
-                                                                      context).FromJust(),
+                                                              indexCount,
                                                               instanceCount, firstIndex,
                                                               baseVertex,
                                                               firstInstance);
@@ -407,7 +434,7 @@ void GPURenderPassEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8::V
         auto index = indexVal->Uint32Value(context).FromJust();
         auto bindgroup = GPUBindGroupImpl::GetPointer(bindGroupVal.As<v8::Object>());
 
-        if (dynamicOffsets->IsUint8Array()) {
+        if (dynamicOffsets->IsUint32Array()) {
             auto buf = dynamicOffsets.As<v8::Uint32Array>();
             auto buffer = buf->Buffer();
             auto store = buffer->GetBackingStore();
@@ -415,11 +442,11 @@ void GPURenderPassEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8::V
             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) 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);
+                                                                    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(),
@@ -435,7 +462,6 @@ void GPURenderPassEncoderImpl::SetIndexBuffer(const v8::FunctionCallbackInfo<v8:
     }
 
     auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
 
     auto bufferVal = args[0];
     auto indexFormatVal = args[1];
@@ -446,7 +472,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()) {
@@ -482,41 +508,13 @@ void GPURenderPassEncoderImpl::SetBlendConstant(const v8::FunctionCallbackInfo<v
     }
 
     auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
 
     auto colorVal = args[0];
 
-    if (colorVal->IsObject()) {
-
-        auto color = CanvasColor{0, 0, 0, 0};
-        auto colorObj = colorVal.As<v8::Object>();
-
-        v8::Local<v8::Value> r;
-        v8::Local<v8::Value> g;
-        v8::Local<v8::Value> b;
-        v8::Local<v8::Value> a;
-
-        colorObj->Get(context, ConvertToV8String(isolate, "r")).ToLocal(&r);
-        colorObj->Get(context, ConvertToV8String(isolate, "g")).ToLocal(&g);
-        colorObj->Get(context, ConvertToV8String(isolate, "b")).ToLocal(&b);
-        colorObj->Get(context, ConvertToV8String(isolate, "a")).ToLocal(&a);
-
-        if (!r.IsEmpty() && r->IsNumber()) {
-            color.r = r.As<v8::Number>()->Value();
-        }
-
-        if (!g.IsEmpty() && g->IsNumber()) {
-            color.g = g.As<v8::Number>()->Value();
-        }
+    if (colorVal->IsObject() || colorVal->IsArray()) {
 
+        auto color = ParseColor(isolate, colorVal);
 
-        if (!b.IsEmpty() && b->IsNumber()) {
-            color.b = b.As<v8::Number>()->Value();
-        }
-
-        if (!a.IsEmpty() && a->IsNumber()) {
-            color.a = a.As<v8::Number>()->Value();
-        }
 
         canvas_native_webgpu_render_pass_encoder_set_blend_constant(ptr->GetPass(), &color);
     }
@@ -530,12 +528,10 @@ void GPURenderPassEncoderImpl::SetPipeline(const v8::FunctionCallbackInfo<v8::Va
     }
 
     auto pipelineVal = args[0];
-    if (pipelineVal->IsObject()) {
+    if (GetNativeType(pipelineVal) == NativeType::GPURenderPipeline) {
         auto pipeline = GPURenderPipelineImpl::GetPointer(pipelineVal.As<v8::Object>());
-        if (pipeline != nullptr) {
-            canvas_native_webgpu_render_pass_encoder_set_pipeline(ptr->GetPass(),
-                                                                  pipeline->GetGPUPipeline());
-        }
+        canvas_native_webgpu_render_pass_encoder_set_pipeline(ptr->GetPass(),
+                                                              pipeline->GetGPUPipeline());
     }
 }
 
@@ -598,12 +594,13 @@ void GPURenderPassEncoderImpl::SetVertexBuffer(const v8::FunctionCallbackInfo<v8
 
     if (slotVal->IsUint32() && bufferVal->IsObject()) {
         auto slot = slotVal.As<v8::Uint32>()->Value();
-        auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
-        if (buffer == nullptr) {
+        if (GetNativeType(bufferVal) != NativeType::GPUBuffer) {
             // todo throw ??
             return;
         }
 
+        auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
+
         if (offsetVal->IsNumber()) {
             offset = (int64_t) offsetVal.As<v8::Number>()->Value();
         }

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

@@ -8,10 +8,11 @@
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
+#include "GPUUtils.h"
 
 class GPURenderPassEncoderImpl : ObjectWrapperImpl {
 public:
-    GPURenderPassEncoderImpl(const CanvasGPURenderPassEncoder *pass);
+    explicit GPURenderPassEncoderImpl(const CanvasGPURenderPassEncoder *pass);
 
     ~GPURenderPassEncoderImpl() {
         canvas_native_webgpu_render_pass_encoder_release(this->GetPass());
@@ -31,12 +32,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPURenderPassEncoderImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPURenderPassEncoder);
+        SetNativeType(encoder, NativeType::GPURenderPassEncoder);
         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 BeginOcclusionQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void Draw(const v8::FunctionCallbackInfo<v8::Value> &args);
@@ -78,7 +82,6 @@ public:
 
 private:
     const CanvasGPURenderPassEncoder *pass_;
-    bool ended_ = false;
 };
 
 

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

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

@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPURenderPipelineImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPURenderPipeline);
+        SetNativeType(pipeline, NativeType::GPURenderPipeline);
         object->SetAlignedPointerInInternalField(0, pipeline);
         pipeline->BindFinalizer(isolate, object);
         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

@@ -22,7 +22,7 @@ void GPUSamplerImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isola
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUSampler"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUSampler"), func).FromJust();
 }
 
 GPUSamplerImpl *GPUSamplerImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -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);
 
@@ -30,12 +30,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUSamplerImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUSampler);
+        SetNativeType(sampler, NativeType::GPUSampler);
         object->SetAlignedPointerInInternalField(0, sampler);
         sampler->BindFinalizer(isolate, object);
         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

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

@@ -11,7 +11,7 @@
 
 class GPUShaderModuleImpl : ObjectWrapperImpl {
 public:
-    GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule);
+    explicit GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule);
 
     ~GPUShaderModuleImpl() {
         canvas_native_webgpu_shader_module_release(this->GetShaderModule());
@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUShaderModuleImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUShaderModule);
+        SetNativeType(shaderModule, NativeType::GPUShaderModule);
         object->SetAlignedPointerInInternalField(0, shaderModule);
         shaderModule->BindFinalizer(isolate, object);
         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/GPUSupportedLimitsImpl.cpp

@@ -22,7 +22,7 @@ void GPUSupportedLimitsImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolat
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUSupportedLimits"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUSupportedLimits"), func).FromJust();
 }
 
 GPUSupportedLimitsImpl *GPUSupportedLimitsImpl::GetPointer(v8::Local<v8::Object> object) {
@@ -281,7 +281,7 @@ void GPUSupportedLimitsImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &arg
 
     ret->SetAlignedPointerInInternalField(0, object);
 
-    SetNativeType(ret, NativeType::GPUSupportedLimits);
+    SetNativeType(object, NativeType::GPUSupportedLimits);
 
     object->BindFinalizer(isolate, ret);
 

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

@@ -10,7 +10,7 @@
 
 class GPUSupportedLimitsImpl : public ObjectWrapperImpl {
 public:
-    GPUSupportedLimitsImpl(CanvasGPUSupportedLimits *limits);
+    explicit GPUSupportedLimitsImpl(CanvasGPUSupportedLimits *limits);
 
     ~GPUSupportedLimitsImpl() {
         canvas_native_webgpu_limits_release(this->limits_);
@@ -23,7 +23,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUSupportedLimitsImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUSupportedLimits);
+        SetNativeType(limits, NativeType::GPUSupportedLimits);
         object->SetAlignedPointerInInternalField(0, limits);
         limits->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -47,6 +47,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 +111,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 +274,7 @@ void GPUTextureImpl::CreateView(const v8::FunctionCallbackInfo<v8::Value> &args)
             aspect, 0, -1, 0, -1
     };
 
+    std::string label;
 
     if (descVal->IsObject()) {
         descriptor = new CanvasCreateTextureViewDescriptor{};
@@ -269,7 +295,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 +322,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 +341,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 = ConvertFromV8String(isolate, labelVal);
+
+        descriptor->label = label.c_str();
 
         v8::Local<v8::Value> dimensionVal;
         if (descObj->Get(context, ConvertToV8String(isolate, "dimension")).ToLocal(&dimensionVal)) {
@@ -347,6 +371,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

@@ -25,17 +25,19 @@ public:
 
     static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUTextureImpl *queue) {
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUTextureImpl *texture) {
         auto context = isolate->GetCurrentContext();
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUTextureImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUTexture);
-        object->SetAlignedPointerInInternalField(0, queue);
-        queue->BindFinalizer(isolate, object);
+        SetNativeType(texture, NativeType::GPUTexture);
+        object->SetAlignedPointerInInternalField(0, texture);
+        texture->BindFinalizer(isolate, object);
         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

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