@nativescript/canvas 2.0.0-webgpu.34 → 2.0.0-webgpu.36

package/platforms/ios/src/cpp/ImageAssetImpl.h

@@ -61,6 +61,10 @@ public:
 
     static void FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void FromEncodedBytesSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FromEncodedBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     /* static void SaveSync(const v8::FunctionCallbackInfo<v8::Value> &args);
 
      static void SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args);*/

package/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.cpp

@@ -141,8 +141,8 @@ WebGLRenderingContextBase::~WebGLRenderingContextBase() {
     if (_raf != nullptr) {
         canvas_native_raf_stop(
                                _raf->GetRaf());
+        canvas_native_raf_release(_raf->GetRaf());
     }
-    canvas_native_raf_release(_raf->GetRaf());
     this->raf_ = nullptr;
     canvas_native_webgl_state_destroy(this->GetState());
     this->state_ = nullptr;

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

@@ -17,7 +17,7 @@ const CanvasGPUComputePassEncoder *GPUComputePassEncoderImpl::GetComputePass() {
 }
 
 
-void GPUComputePassEncoderImpl::Init(v8::Local <v8::Object> canvasModule, v8::Isolate *isolate) {
+void GPUComputePassEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
     v8::Locker locker(isolate);
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
@@ -31,7 +31,7 @@ void GPUComputePassEncoderImpl::Init(v8::Local <v8::Object> canvasModule, v8::Is
 }
 
 GPUComputePassEncoderImpl *
-GPUComputePassEncoderImpl::GetPointer(const v8::Local <v8::Object> &object) {
+GPUComputePassEncoderImpl::GetPointer(const v8::Local<v8::Object> &object) {
     auto ptr = object->GetAlignedPointerFromInternalField(0);
     if (ptr == nullptr) {
         return nullptr;
@@ -39,14 +39,14 @@ GPUComputePassEncoderImpl::GetPointer(const v8::Local <v8::Object> &object) {
     return static_cast<GPUComputePassEncoderImpl *>(ptr);
 }
 
-v8::Local <v8::FunctionTemplate> GPUComputePassEncoderImpl::GetCtor(v8::Isolate *isolate) {
+v8::Local<v8::FunctionTemplate> GPUComputePassEncoderImpl::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->GPUComputePassEncoderTmpl.get();
     if (ctor != nullptr) {
         return ctor->Get(isolate);
     }
 
-    v8::Local <v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
     ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
     ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUComputePassEncoder"));
 
@@ -92,14 +92,14 @@ v8::Local <v8::FunctionTemplate> GPUComputePassEncoderImpl::GetCtor(v8::Isolate
 
 
     cache->GPUComputePassEncoderTmpl =
-            std::make_unique<v8::Persistent < v8::FunctionTemplate>>
-    (isolate, ctorTmpl);
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>
+                    (isolate, ctorTmpl);
     return ctorTmpl;
 }
 
 void
-GPUComputePassEncoderImpl::GetLabel(v8::Local <v8::Name> name,
-                                    const v8::PropertyCallbackInfo <v8::Value> &info) {
+GPUComputePassEncoderImpl::GetLabel(v8::Local<v8::Name> name,
+                                    const v8::PropertyCallbackInfo<v8::Value> &info) {
     auto ptr = GetPointer(info.This());
     if (ptr != nullptr) {
         auto label = canvas_native_webgpu_compute_pass_encoder_get_label(ptr->computePass_);
@@ -119,7 +119,7 @@ GPUComputePassEncoderImpl::GetLabel(v8::Local <v8::Name> name,
 
 
 void
-GPUComputePassEncoderImpl::DispatchWorkgroups(const v8::FunctionCallbackInfo <v8::Value> &args) {
+GPUComputePassEncoderImpl::DispatchWorkgroups(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -154,7 +154,7 @@ GPUComputePassEncoderImpl::DispatchWorkgroups(const v8::FunctionCallbackInfo <v8
 }
 
 void GPUComputePassEncoderImpl::DispatchWorkgroupsIndirect(
-        const v8::FunctionCallbackInfo <v8::Value> &args) {
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -178,7 +178,7 @@ void GPUComputePassEncoderImpl::DispatchWorkgroupsIndirect(
 }
 
 
-void GPUComputePassEncoderImpl::End(const v8::FunctionCallbackInfo <v8::Value> &args) {
+void GPUComputePassEncoderImpl::End(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -188,7 +188,7 @@ void GPUComputePassEncoderImpl::End(const v8::FunctionCallbackInfo <v8::Value> &
 }
 
 void
-GPUComputePassEncoderImpl::InsertDebugMarker(const v8::FunctionCallbackInfo <v8::Value> &args) {
+GPUComputePassEncoderImpl::InsertDebugMarker(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -204,7 +204,7 @@ GPUComputePassEncoderImpl::InsertDebugMarker(const v8::FunctionCallbackInfo <v8:
     }
 }
 
-void GPUComputePassEncoderImpl::PopDebugGroup(const v8::FunctionCallbackInfo <v8::Value> &args) {
+void GPUComputePassEncoderImpl::PopDebugGroup(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -213,7 +213,7 @@ void GPUComputePassEncoderImpl::PopDebugGroup(const v8::FunctionCallbackInfo <v8
     canvas_native_webgpu_compute_pass_encoder_pop_debug_group(ptr->GetComputePass());
 }
 
-void GPUComputePassEncoderImpl::PushDebugGroup(const v8::FunctionCallbackInfo <v8::Value> &args) {
+void GPUComputePassEncoderImpl::PushDebugGroup(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -229,7 +229,7 @@ void GPUComputePassEncoderImpl::PushDebugGroup(const v8::FunctionCallbackInfo <v
     }
 }
 
-void GPUComputePassEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo <v8::Value> &args) {
+void GPUComputePassEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -244,34 +244,39 @@ void GPUComputePassEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo <v8:
     auto dynamicOffsetsStart = args[3];
     auto dynamicOffsetsLength = args[4];
 
+    const CanvasGPUBindGroup *bindGroup = nullptr;
+
     auto type = GetNativeType(bindGroupVal);
 
     if (type == NativeType::GPUBindGroup) {
-        auto index = indexVal->Uint32Value(context).FromJust();
-        auto bindgroup = GPUBindGroupImpl::GetPointer(bindGroupVal.As<v8::Object>());
-
-        if (dynamicOffsets->IsUint8Array()) {
-            auto buf = dynamicOffsets.As<v8::Uint32Array>();
-            auto buffer = buf->Buffer();
-            auto store = buffer->GetBackingStore();
-            auto offset = buf->ByteOffset();
-            auto data = static_cast<uint8_t *>(buffer->GetBackingStore()->Data()) + offset;
-            auto size = buf->Length();
-            auto start = (size_t) dynamicOffsetsStart->NumberValue(context).FromJust();
-            auto offset_length = (size_t) dynamicOffsetsLength->NumberValue(context).FromJust();
-            canvas_native_webgpu_compute_pass_encoder_set_bind_group(ptr->GetComputePass(), index,
-                                                                     bindgroup->GetBindGroup(),
-                                                                     static_cast<const uint32_t *>(static_cast<void *>(data)),
-                                                                     size, start, offset_length);
-        } else {
-            canvas_native_webgpu_compute_pass_encoder_set_bind_group(ptr->GetComputePass(), index,
-                                                                     bindgroup->GetBindGroup(),
-                                                                     nullptr, 0, 0, 0);
-        }
+        auto group = GPUBindGroupImpl::GetPointer(bindGroupVal.As<v8::Object>());
+        bindGroup = group->GetBindGroup();
+    }
+
+    auto index = indexVal->Uint32Value(context).FromJust();
+
+
+    if (dynamicOffsets->IsUint8Array()) {
+        auto buf = dynamicOffsets.As<v8::Uint32Array>();
+        auto buffer = buf->Buffer();
+        auto store = buffer->GetBackingStore();
+        auto offset = buf->ByteOffset();
+        auto data = static_cast<uint8_t *>(buffer->GetBackingStore()->Data()) + offset;
+        auto size = buf->Length();
+        auto start = (size_t) dynamicOffsetsStart->NumberValue(context).FromJust();
+        auto offset_length = (size_t) dynamicOffsetsLength->NumberValue(context).FromJust();
+        canvas_native_webgpu_compute_pass_encoder_set_bind_group(ptr->GetComputePass(), index,
+                                                                 bindGroup,
+                                                                 static_cast<const uint32_t *>(static_cast<void *>(data)),
+                                                                 size, start, offset_length);
+    } else {
+        canvas_native_webgpu_compute_pass_encoder_set_bind_group(ptr->GetComputePass(), index,
+                                                                 bindGroup,
+                                                                 nullptr, 0, 0, 0);
     }
 }
 
-void GPUComputePassEncoderImpl::SetPipeline(const v8::FunctionCallbackInfo <v8::Value> &args) {
+void GPUComputePassEncoderImpl::SetPipeline(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;

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

@@ -91,7 +91,7 @@ v8::Local<v8::FunctionTemplate> GPUQueueImpl::GetCtor(v8::Isolate *isolate) {
 
 void
 GPUQueueImpl::GetLabel(v8::Local<v8::Name> name,
-                                const v8::PropertyCallbackInfo<v8::Value> &info) {
+                       const v8::PropertyCallbackInfo<v8::Value> &info) {
     auto ptr = GetPointer(info.This());
     if (ptr != nullptr) {
         auto label = canvas_native_webgpu_queue_get_label(ptr->queue_);
@@ -136,7 +136,9 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
         U8Buffer *buffer = nullptr;
         uint32_t width = 0;
         uint32_t height = 0;
-        const ImageAsset* imageAsset = nullptr;
+        const ImageAsset *imageAsset = nullptr;
+        const WebGLState *gl = nullptr;
+        const CanvasRenderingContext2D *c2d = nullptr;
         if (sourceType == NativeType::ImageBitmap) {
             auto bitmap = ImageBitmapImpl::GetPointer(sourceSourceValue.As<v8::Object>());
             imageAsset = bitmap->GetImageAsset();
@@ -149,12 +151,14 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
             width = canvas_native_image_data_get_width(imageData->GetImageData());
             height = canvas_native_image_data_get_height(imageData->GetImageData());
         } else if (sourceType == NativeType::CanvasRenderingContext2D) {
-            auto c2d = CanvasRenderingContext2DImpl::GetPointer(sourceSourceValue.As<v8::Object>());
+            auto ctx = CanvasRenderingContext2DImpl::GetPointer(sourceSourceValue.As<v8::Object>());
+            c2d = ctx->GetContext();
         } else if (sourceType == NativeType::WebGLRenderingContextBase) {
             auto webgl = WebGLRenderingContextBase::GetPointer(sourceSourceValue.As<v8::Object>());
+            gl = webgl->GetState();
         }
 
-        if (buffer == nullptr && imageAsset == nullptr) {
+        if (buffer == nullptr && imageAsset == nullptr && gl == nullptr && c2d == nullptr) {
             // todo error ??
             return;
         }
@@ -260,7 +264,7 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
 
         CanvasExtent3d extent3D = ParseExtent3d(isolate, sizeVal);
 
-        if (imageAsset != nullptr){
+        if (imageAsset != nullptr) {
             CanvasImageCopyImageAsset source{
                     imageAsset,
                     sourceOrigin,
@@ -269,8 +273,37 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
 
 
             canvas_native_webgpu_queue_copy_image_asset_to_texture(ptr->GetGPUQueue(), &source,
-                                                                      &destination,
-                                                                      &extent3D);
+                                                                   &destination,
+                                                                   &extent3D);
+            return;
+        }
+
+
+        if (c2d != nullptr) {
+            CanvasImageCopyCanvasRenderingContext2D source{
+                    c2d,
+                    sourceOrigin,
+                    flipY,
+            };
+
+
+            canvas_native_webgpu_queue_copy_context_to_texture(ptr->GetGPUQueue(), &source,
+                                                               &destination,
+                                                               &extent3D);
+            return;
+        }
+
+        if (gl != nullptr) {
+            CanvasImageCopyWebGL source{
+                    gl,
+                    sourceOrigin,
+                    flipY,
+            };
+
+
+            canvas_native_webgpu_queue_copy_webgl_to_texture(ptr->GetGPUQueue(), &source,
+                                                             &destination,
+                                                             &extent3D);
             return;
         }
 
@@ -279,7 +312,6 @@ void GPUQueueImpl::CopyExternalImageToTexture(const v8::FunctionCallbackInfo<v8:
         auto size = canvas_native_u8_buffer_get_length(buffer);
 
 
-
         if (data == nullptr || size == 0) {
             // todo error
             return;

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

@@ -118,7 +118,7 @@ v8::Local<v8::FunctionTemplate> GPURenderBundleEncoderImpl::GetCtor(v8::Isolate
 
 void
 GPURenderBundleEncoderImpl::GetLabel(v8::Local<v8::Name> name,
-                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+                                     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_);
@@ -369,30 +369,33 @@ void GPURenderBundleEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8:
     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->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_bundle_encoder_set_bind_group(ptr->GetEncoder(), index,
-                                                                      bindGroup->GetBindGroup(),
-                                                                      static_cast<const uint32_t *>(static_cast<void *>(data)),
-                                                                      size, start, offset_length);
-        } else {
-            canvas_native_webgpu_render_bundle_encoder_set_bind_group(ptr->GetEncoder(), 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_bundle_encoder_set_bind_group(ptr->GetEncoder(), index,
+                                                                  bindGroup,
+                                                                  static_cast<const uint32_t *>(static_cast<void *>(data)),
+                                                                  size, start, offset_length);
+    } else {
+        canvas_native_webgpu_render_bundle_encoder_set_bind_group(ptr->GetEncoder(), index,
+                                                                  bindGroup,
+                                                                  nullptr, 0, 0, 0);
     }
 
 }
@@ -450,7 +453,7 @@ void GPURenderBundleEncoderImpl::SetPipeline(const v8::FunctionCallbackInfo<v8::
     }
 
     auto pipelineVal = args[0];
-    if(GetNativeType(pipelineVal) == NativeType::GPURenderPipeline){
+    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(),

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

@@ -79,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));
@@ -291,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
@@ -318,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) {
@@ -428,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->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->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);
     }
 }
 
@@ -596,8 +667,7 @@ void GPURenderPassEncoderImpl::SetVertexBuffer(const v8::FunctionCallbackInfo<v8
     if (type == NativeType::GPUBuffer) {
         auto context = isolate->GetCurrentContext();
         auto slot = slotVal->ToUint32(context).ToLocalChecked();
-        
-    
+
 
         auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
 

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

@@ -51,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/utils.d.ts

@@ -4,6 +4,6 @@ export declare class Utils {
     static _CHECKED_FOR_SUPPORT: boolean;
     static toJSArray(array: any): any[];
     static get IS_SUPPORTED_TYPED_ARRAYS_VERSION(): boolean;
-    static isTypedArray(value: any): value is Uint32Array | Uint8Array | Uint8ClampedArray | Int8Array | Uint16Array | Int16Array | Int32Array | Float32Array;
+    static isTypedArray(value: any): value is Uint32Array | Uint8ClampedArray | Uint8Array | Int32Array | Float32Array | Int8Array | Uint16Array | Int16Array;
 }
 export default function lazy<T>(action: () => T): () => T;