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

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

@@ -30,12 +30,14 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUDeviceImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUDevice);
+        SetNativeType(device, NativeType::GPUDevice);
         object->SetAlignedPointerInInternalField(0, device);
         device->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
 
     static void GetFeatures(v8::Local<v8::Name> name,
                             const v8::PropertyCallbackInfo<v8::Value> &info);

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

@@ -20,7 +20,7 @@ void GPUImpl::Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate *isola
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPU"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPU"), func).FromJust();
 }
 
 
@@ -69,7 +69,7 @@ void GPUImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     ret->SetAlignedPointerInInternalField(0, object);
 
-    SetNativeType(ret, NativeType::GPUInstance);
+    SetNativeType(object, NativeType::GPUInstance);
 
     object->BindFinalizer(isolate, ret);
 
@@ -122,49 +122,63 @@ void GPUImpl::RequestAdapter(const v8::FunctionCallbackInfo<v8::Value> &args) {
         }
     }
 
-    v8::Global<v8::Function> func(isolate, args[1].As<v8::Function>());
+
     auto callback = new AsyncCallback{
             isolate,
-            std::move(func)
+            args[1].As<v8::Function>(),
+            [](bool done, void *data) {
+                if (data != nullptr) {
+                    auto async_data = static_cast<AsyncCallback *>(data);
+                    auto func = async_data->inner_.get();
+                    if (func != nullptr && func->isolate_ != nullptr) {
+                        v8::Isolate *isolate = func->isolate_;
+                        v8::Locker locker(isolate);
+                        v8::Isolate::Scope isolate_scope(isolate);
+                        v8::HandleScope handle_scope(isolate);
+                        v8::Local<v8::Function> callback = func->callback_.Get(
+                                isolate);
+                        v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                        v8::Context::Scope context_scope(context);
+
+                        if (func->data != nullptr) {
+                            auto impl = new GPUAdapterImpl(
+                                    static_cast<const CanvasGPUAdapter *>(func->data));
+                            auto ret = GPUAdapterImpl::NewInstance(
+                                    isolate, impl);
+
+
+                            v8::Local<v8::Value> args[2] = {
+                                    v8::Null(isolate), ret};
+
+
+                            callback->Call(context, context->Global(),
+                                           2,
+                                           args);  // ignore JS return value
+                            
+                            delete static_cast<AsyncCallback *>(data);
+
+                        } else {
+                            v8::Local<v8::Value> args[1] = {
+                                    v8::Null(isolate)};
+
+                            callback->Call(context, context->Global(),
+                                           1,
+                                           args);  // ignore JS return value
+                            delete static_cast<AsyncCallback *>(data);
+                        }
+                    }
+                }
+            }
     };
+    callback->prepare();
     canvas_native_webgpu_request_adapter(ptr->GetGPUInstance(), &opts,
                                          [](const CanvasGPUAdapter *adapter, void *data) {
                                              if (data != nullptr) {
-                                                 auto func = static_cast<AsyncCallback *>(data);
-                                                 if (func->isolate != nullptr) {
-                                                     v8::Isolate *isolate = func->isolate;
-                                                     v8::Locker locker(isolate);
-                                                     v8::Isolate::Scope isolate_scope(isolate);
-                                                     v8::HandleScope handle_scope(isolate);
-                                                     v8::Local<v8::Function> callback = func->callback.Get(
-                                                             isolate);
-                                                     v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                                     v8::Context::Scope context_scope(context);
-
-                                                     if (adapter != nullptr) {
-                                                         auto impl = new GPUAdapterImpl(adapter);
-                                                         auto ret = GPUAdapterImpl::NewInstance(
-                                                                 isolate, impl);
-
-
-                                                         v8::Local<v8::Value> args[2] = {
-                                                                 v8::Null(isolate), ret};
-
-
-                                                         callback->Call(context, context->Global(),
-                                                                        2,
-                                                                        args);  // ignore JS return value
-
-                                                         delete static_cast<AsyncCallback *>(data);
-                                                     } else {
-                                                         v8::Local<v8::Value> args[1] = {
-                                                                 v8::Null(isolate)};
-
-                                                         callback->Call(context, context->Global(),
-                                                                        1,
-                                                                        args);  // ignore JS return value
-                                                         delete static_cast<AsyncCallback *>(data);
-                                                     }
+                                                 auto async_data = static_cast<AsyncCallback *>(data);
+                                                 auto inner = async_data->inner_.get();
+                                                 if (inner != nullptr) {
+                                                     inner->data = (void *) adapter;
+                                                     async_data->execute(true);
                                                  }
                                              }
                                          }, callback);

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

@@ -12,7 +12,7 @@
 
 class GPUImpl : ObjectWrapperImpl {
 public:
-    GPUImpl(const CanvasWebGPUInstance *instance);
+    explicit GPUImpl(const CanvasWebGPUInstance *instance);
 
     ~GPUImpl() {
         if (this->instance_ != nullptr) {
@@ -37,7 +37,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUInstance);
+        SetNativeType(instance, NativeType::GPUInstance);
         object->SetAlignedPointerInInternalField(0, instance);
         instance->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -0,0 +1,33 @@
+//
+// Created by Osei Fortune on 19/08/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPULABEL_H
+#define CANVAS_ANDROID_GPULABEL_H
+
+#include "Common.h"
+#include "Helpers.h"
+
+class GPULabel {
+public:
+    GPULabel(){}
+    GPULabel(v8::Isolate *isolate, const v8::Local<v8::Value> &label) {
+        if (label->IsString() || label->IsStringObject()) {
+            label_ = ConvertFromV8String(isolate, label);
+            hasLabel_ = true;
+        }
+    }
+
+    const char *operator*() {
+        if (hasLabel_) {
+            return label_.c_str();
+        }
+        return nullptr;
+    }
+
+private:
+    std::string label_;
+    bool hasLabel_ = false;
+};
+
+#endif //CANVAS_ANDROID_GPULABEL_H

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

@@ -22,7 +22,7 @@ void GPUPipelineLayoutImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUPipelineLayout"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUPipelineLayout"), func).FromJust();
 }
 
 GPUPipelineLayoutImpl *GPUPipelineLayoutImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -47,8 +47,34 @@ v8::Local<v8::FunctionTemplate> GPUPipelineLayoutImpl::GetCtor(v8::Isolate *isol
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     cache->GPUPipelineLayoutTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
 
+
+void
+GPUPipelineLayoutImpl::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_pipeline_layout_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/GPUPipelineLayoutImpl.h

@@ -12,7 +12,7 @@
 
 class GPUPipelineLayoutImpl : ObjectWrapperImpl {
 public:
-    GPUPipelineLayoutImpl(const CanvasGPUPipelineLayout *pipeline);
+    explicit GPUPipelineLayoutImpl(const CanvasGPUPipelineLayout *pipeline);
 
     ~GPUPipelineLayoutImpl() {
         canvas_native_webgpu_pipeline_layout_release(this->GetPipeline());
@@ -26,17 +26,20 @@ public:
 
     static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUPipelineLayoutImpl *device) {
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, GPUPipelineLayoutImpl *pipeline) {
         auto context = isolate->GetCurrentContext();
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUPipelineLayoutImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUPipelineLayout);
-        object->SetAlignedPointerInInternalField(0, device);
-        device->BindFinalizer(isolate, object);
+        SetNativeType(pipeline, NativeType::GPUPipelineLayout);
+        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);
 
 private:
     const CanvasGPUPipelineLayout *pipeline_;

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

@@ -21,7 +21,7 @@ void GPUQuerySetImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isol
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUQuerySet"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUQuerySet"), func).FromJust();
 }
 
 GPUQuerySetImpl *GPUQuerySetImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -78,7 +78,6 @@ void
 GPUQuerySetImpl::GetCount(v8::Local<v8::Name> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info) {
     auto ptr = GetPointer(info.This());
-    auto isolate = info.GetIsolate();
     if (ptr != nullptr) {
         info.GetReturnValue().Set(canvas_native_webgpu_query_set_get_count(ptr->GetQuerySet()));
         return;
@@ -132,6 +131,6 @@ void GPUQuerySetImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
     if (ptr == nullptr) {
         return;
     }
-    // todo
+    canvas_native_webgpu_query_set_destroy(ptr->querySet_);
 
 }

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

@@ -10,7 +10,7 @@
 
 class GPUQuerySetImpl : ObjectWrapperImpl {
 public:
-    GPUQuerySetImpl(const CanvasGPUQuerySet *querySet);
+    explicit GPUQuerySetImpl(const CanvasGPUQuerySet *querySet);
 
     ~GPUQuerySetImpl() {
         canvas_native_webgpu_query_set_release(this->GetQuerySet());
@@ -29,7 +29,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUQuerySetImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUQuerySet);
+        SetNativeType(querySet, NativeType::GPUQuerySet);
         object->SetAlignedPointerInInternalField(0, querySet);
         querySet->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -30,7 +30,7 @@ void GPUQueueImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUQueue"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUQueue"), func).FromJust();
 }
 
 GPUQueueImpl *GPUQueueImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -55,6 +55,10 @@ v8::Local<v8::FunctionTemplate> GPUQueueImpl::GetCtor(v8::Isolate *isolate) {
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
 
     tmpl->Set(
             ConvertToV8String(isolate, "copyExternalImageToTexture"),
@@ -84,6 +88,28 @@ v8::Local<v8::FunctionTemplate> GPUQueueImpl::GetCtor(v8::Isolate *isolate) {
     return ctorTmpl;
 }
 
+
+void
+GPUQueueImpl::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_queue_get_label(ptr->queue_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}
+
+
 void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
@@ -110,16 +136,13 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
         U8Buffer *buffer = nullptr;
         uint32_t width = 0;
         uint32_t height = 0;
+        const ImageAsset* imageAsset = nullptr;
         if (sourceType == NativeType::ImageBitmap) {
-            auto imageAsset = ImageBitmapImpl::GetPointer(sourceSourceValue.As<v8::Object>());
-            buffer = canvas_native_image_asset_get_data(imageAsset->GetImageAsset());
-            width = canvas_native_image_asset_width(imageAsset->GetImageAsset());
-            height = canvas_native_image_asset_height(imageAsset->GetImageAsset());
+            auto bitmap = ImageBitmapImpl::GetPointer(sourceSourceValue.As<v8::Object>());
+            imageAsset = bitmap->GetImageAsset();
         } else if (sourceType == NativeType::ImageAsset) {
-            auto imageAsset = ImageAssetImpl::GetPointer(sourceSourceValue.As<v8::Object>());
-            buffer = canvas_native_image_asset_get_data(imageAsset->GetImageAsset());
-            width = canvas_native_image_asset_width(imageAsset->GetImageAsset());
-            height = canvas_native_image_asset_height(imageAsset->GetImageAsset());
+            auto asset = ImageAssetImpl::GetPointer(sourceSourceValue.As<v8::Object>());
+            imageAsset = asset->GetImageAsset();
         } else if (sourceType == NativeType::ImageData) {
             auto imageData = ImageDataImpl::GetPointer(sourceSourceValue.As<v8::Object>());
             buffer = canvas_native_image_data_get_data(imageData->GetImageData());
@@ -131,7 +154,7 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
             auto webgl = WebGLRenderingContextBase::GetPointer(sourceSourceValue.As<v8::Object>());
         }
 
-        if (buffer == nullptr) {
+        if (buffer == nullptr && imageAsset == nullptr) {
             // todo error ??
             return;
         }
@@ -237,9 +260,26 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
 
         CanvasExtent3d extent3D = ParseExtent3d(isolate, sizeVal);
 
+        if (imageAsset != nullptr){
+            CanvasImageCopyImageAsset source{
+                    imageAsset,
+                    sourceOrigin,
+                    flipY,
+            };
+
+
+            canvas_native_webgpu_queue_copy_image_asset_to_texture(ptr->GetGPUQueue(), &source,
+                                                                      &destination,
+                                                                      &extent3D);
+            return;
+        }
+
+
         auto data = canvas_native_u8_buffer_get_bytes(buffer);
         auto size = canvas_native_u8_buffer_get_length(buffer);
 
+
+
         if (data == nullptr || size == 0) {
             // todo error
             return;
@@ -306,33 +346,48 @@ void GPUQueueImpl::SubmitWorkDone(const v8::FunctionCallbackInfo<v8::Value> &arg
     }
 
     auto isolate = args.GetIsolate();
+    auto cb = args[0].As<v8::Function>();
+    auto callback = new AsyncCallback(isolate, cb, [](bool done, void *data) {
+        if (data != nullptr) {
+            auto async_data = static_cast<AsyncCallback *>(data);
+            auto func = async_data->inner_.get();
+            if (func != nullptr && func->isolate_ != nullptr) {
+                v8::Isolate *isolate = func->isolate_;
+                v8::Locker locker(isolate);
+                v8::Isolate::Scope isolate_scope(
+                        isolate);
+                v8::HandleScope handle_scope(
+                        isolate);
+                v8::Local<v8::Function> callback = func->callback_.Get(
+                        isolate);
+                v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                v8::Context::Scope context_scope(
+                        context);
+
+                if (func->data != nullptr) {
+                    // todo handle error
+                    canvas_native_string_destroy(static_cast<char *>(func->data));
+                    func->data = nullptr;
+                }
 
-    auto cb = args[0];
-    auto callback = new JSICallback(isolate, cb.As<v8::Function>());
-
-    canvas_native_webgpu_queue_on_submitted_work_done(ptr->GetGPUQueue(),
-                                                      [](char *error, void *data) {
-                                                          auto cb = static_cast<JSICallback *>(data);
-
-                                                          v8::Isolate *isolate = cb->isolate_;
-                                                          v8::Locker locker(isolate);
-                                                          v8::Isolate::Scope isolate_scope(
-                                                                  isolate);
-                                                          v8::HandleScope handle_scope(
-                                                                  isolate);
-                                                          v8::Local<v8::Function> callback = cb->callback_->Get(
-                                                                  isolate);
-                                                          v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                                          v8::Context::Scope context_scope(
-                                                                  context);
+                callback->Call(context,
+                               context->Global(),
+                               0, nullptr);
 
+                delete static_cast<AsyncCallback *>(data);
+            }
 
-                                                          callback->Call(context,
-                                                                         context->Global(),
-                                                                         0, nullptr);
+        }
+    });
 
+    callback->prepare();
 
-                                                          delete static_cast<JSICallback *>(data);
+    canvas_native_webgpu_queue_on_submitted_work_done(ptr->GetGPUQueue(),
+                                                      [](char *error, void *data) {
+                                                          if (data != nullptr) {
+                                                              auto async_data = static_cast<AsyncCallback *>(data);
+                                                              async_data->execute(true);
+                                                          }
                                                       },
                                                       callback);
 
@@ -353,7 +408,6 @@ void GPUQueueImpl::WriteBuffer(const v8::FunctionCallbackInfo<v8::Value> &args)
     if (bufferValue->IsObject()) {
         auto buffer = GPUBufferImpl::GetPointer(bufferValue.As<v8::Object>());
 
-
         auto bufferOffset = (uint64_t) args[1].As<v8::Number>()->Value();
 
         auto dataValue = args[2].As<v8::TypedArray>();
@@ -364,7 +418,7 @@ void GPUQueueImpl::WriteBuffer(const v8::FunctionCallbackInfo<v8::Value> &args)
 
         auto data = static_cast<uint8_t *>(store->Data()) + offset;
 
-        auto data_size = store->ByteLength();
+        auto data_size = store->ByteLength() - offset;
 
         auto dataOffset = (uint64_t) args[3].As<v8::Number>()->Value();
 
@@ -395,8 +449,6 @@ void GPUQueueImpl::WriteTexture(const v8::FunctionCallbackInfo<v8::Value> &args)
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    bool flipY = false;
-
 
     auto destinationVal = args[0];
     auto dataVal = args[1];

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

@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUQueueImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUQueue);
+        SetNativeType(queue, NativeType::GPUQueue);
         object->SetAlignedPointerInInternalField(0, queue);
         queue->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void Submit(const v8::FunctionCallbackInfo<v8::Value> &args);

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

@@ -8,6 +8,7 @@
 #include "GPUBufferImpl.h"
 #include "GPURenderBundleImpl.h"
 #include "GPUBindGroupImpl.h"
+#include "GPULabel.h"
 
 GPURenderBundleEncoderImpl::GPURenderBundleEncoderImpl(const CanvasGPURenderBundleEncoder *encoder)
         : encoder_(
@@ -54,6 +55,11 @@ v8::Local<v8::FunctionTemplate> GPURenderBundleEncoderImpl::GetCtor(v8::Isolate
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
     tmpl->Set(
             ConvertToV8String(isolate, "draw"),
             v8::FunctionTemplate::New(isolate, &Draw));
@@ -109,6 +115,28 @@ v8::Local<v8::FunctionTemplate> GPURenderBundleEncoderImpl::GetCtor(v8::Isolate
     return ctorTmpl;
 }
 
+
+void
+GPURenderBundleEncoderImpl::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_bundle_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 GPURenderBundleEncoderImpl::Draw(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
@@ -163,12 +191,16 @@ void GPURenderBundleEncoderImpl::DrawIndexed(const v8::FunctionCallbackInfo<v8::
 
 
     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();
@@ -256,7 +288,7 @@ void GPURenderBundleEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    char *label = nullptr;
+    GPULabel label;
     v8::Local<v8::Value> labelVal;
 
     auto optionsVal = args[0];
@@ -265,13 +297,11 @@ void GPURenderBundleEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value
         auto options = optionsVal.As<v8::Object>();
         options->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
 
-        if (!labelVal.IsEmpty() && labelVal->IsString()) {
-            label = *v8::String::Utf8Value(isolate, labelVal);
-        }
+        label = GPULabel(isolate, labelVal);
     }
 
 
-    auto bundle = canvas_native_webgpu_render_bundle_encoder_finish(ptr->GetEncoder(), label);
+    auto bundle = canvas_native_webgpu_render_bundle_encoder_finish(ptr->GetEncoder(), *label);
 
     if (bundle != nullptr) {
         auto ret = GPURenderBundleImpl::NewInstance(isolate, new GPURenderBundleImpl(bundle));
@@ -345,7 +375,7 @@ void GPURenderBundleEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8:
         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();
@@ -374,7 +404,6 @@ void GPURenderBundleEncoderImpl::SetIndexBuffer(const v8::FunctionCallbackInfo<v
     }
 
     auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
 
     auto bufferVal = args[0];
     auto indexFormatVal = args[1];
@@ -385,7 +414,7 @@ void GPURenderBundleEncoderImpl::SetIndexBuffer(const v8::FunctionCallbackInfo<v
 
     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()) {
@@ -421,7 +450,7 @@ void GPURenderBundleEncoderImpl::SetPipeline(const v8::FunctionCallbackInfo<v8::
     }
 
     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_bundle_encoder_set_pipeline(ptr->GetEncoder(),
@@ -445,11 +474,11 @@ void GPURenderBundleEncoderImpl::SetVertexBuffer(const v8::FunctionCallbackInfo<
 
     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();