@nativescript/canvas 2.0.0-webgpu.33 → 2.0.0-webgpu.35

package/platforms/ios/src/cpp/CanvasJSIModule.cpp

@@ -233,7 +233,7 @@ void CanvasJSIModule::Create2DContext(const v8::FunctionCallbackInfo<v8::Value>
     auto context = isolate->GetCurrentContext();
     auto ptr = args[0].As<v8::BigInt>()->Int64Value();
 
-    auto context_2d = static_cast<CanvasRenderingContext2D *>((void *)ptr);
+    auto context_2d = static_cast<CanvasRenderingContext2D *>((void *) ptr);
 
     auto ret = CanvasRenderingContext2DImpl::NewInstance(isolate, new CanvasRenderingContext2DImpl(
             context_2d));
@@ -358,7 +358,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                         isolate, ta);
 
                 auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
-                    if(data == nullptr){return;}
+                    if (data == nullptr) { return; }
                     auto async_data = static_cast<AsyncCallback *>(data);
                     auto func = async_data->inner_.get();
                     if (func != nullptr && func->isolate_ != nullptr) {
@@ -598,7 +598,7 @@ void CanvasJSIModule::Create2DContextWithPointer(const v8::FunctionCallbackInfo<
 
 struct FileData {
     char *error_;
-    U8Buffer* data;
+    U8Buffer *data;
 
     ~FileData() {
         if (error_ != nullptr) {
@@ -615,7 +615,7 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
 
 
     auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
-        if(data == nullptr){return;}
+        if (data == nullptr) { return; }
         auto async_data = static_cast<AsyncCallback *>(data);
         auto func = async_data->inner_.get();
         if (func != nullptr && func->isolate_ != nullptr) {
@@ -624,12 +624,12 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
             v8::Isolate::Scope isolate_scope(isolate);
             v8::HandleScope handle_scope(isolate);
             v8::Local<v8::Function> callback = func->callback_.Get(
-                                                                   isolate);
+                    isolate);
             v8::Local<v8::Context> context = callback->GetCreationContextChecked();
             v8::Context::Scope context_scope(context);
 
             if (func->data != nullptr) {
-                auto file_data = static_cast<FileData*>(func->data);
+                auto file_data = static_cast<FileData *>(func->data);
 
                 v8::Local<v8::Value> args[2];
 
@@ -701,11 +701,11 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
 
                 if (!canvas_native_helper_read_file_has_error(ret)) {
                     auto buf = canvas_native_helper_read_file_take_data(ret);
-                    callback->inner_->data = new FileData {nullptr, buf};
+                    callback->inner_->data = new FileData{nullptr, buf};
                     done = true;
                 } else {
                     auto error = canvas_native_helper_read_file_get_error(ret);
-                    callback->inner_->data = new FileData {const_cast<char *>(error), nullptr};
+                    callback->inner_->data = new FileData{const_cast<char *>(error), nullptr};
                 }
                 canvas_native_helper_release(ret);
                 callback->execute(done);
@@ -714,7 +714,6 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
     thread.detach();
 
 
-
 }
 
 void CanvasJSIModule::CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -734,7 +733,7 @@ void CanvasJSIModule::CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Valu
     auto count = args.Length();
     if (count == 6) {
         auto ctx = args[1].As<v8::BigInt>()->Int64Value();
-        auto webgl = static_cast<WebGLState*>((void *)ctx);
+        auto webgl = (WebGLState *) ctx;
 
         auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
                                                                    new WebGLRenderingContext(
@@ -817,8 +816,8 @@ void CanvasJSIModule::CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Val
 
     auto count = args.Length();
     if (count == 6) {
-        auto ctx = args[0].As<v8::BigInt>()->Int64Value();
-        auto webgl = static_cast<WebGLState*>((void *)ctx);
+        auto ctx = args[1].As<v8::BigInt>()->Int64Value();
+        auto webgl = (WebGLState *) ctx;
         auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
                                                                     new WebGL2RenderingContext(
                                                                             webgl,

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/GPUDeviceImpl.cpp

@@ -1295,12 +1295,12 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
     auto options = optionsVal.As<v8::Object>();
 
     v8::Local<v8::Value> stencilValue;
-    options->Get(context, ConvertToV8String(isolate, "depthStencil")).ToLocal(
+    auto hasDepthStencil = options->Get(context, ConvertToV8String(isolate, "depthStencil")).ToLocal(
             &stencilValue);
 
     CanvasDepthStencilState *stencil = nullptr;
 
-    if (!stencilValue.IsEmpty() && stencilValue->IsObject()) {
+    if (hasDepthStencil && stencilValue->IsObject()) {
         auto stencilObj = stencilValue.As<v8::Object>();
         stencil = new CanvasDepthStencilState{};
         stencil->depth_bias = 0;
@@ -1491,14 +1491,14 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> fragmentValue;
-    options->Get(context, ConvertToV8String(isolate, "fragment")).ToLocal(
+    auto hasFragment = options->Get(context, ConvertToV8String(isolate, "fragment")).ToLocal(
             &fragmentValue);
 
     CanvasFragmentState *fragment = nullptr;
 
     std::vector<CanvasColorTargetState> targets;
 
-    if (!fragmentValue.IsEmpty() && fragmentValue->IsObject()) {
+    if (hasFragment && fragmentValue->IsObject()) {
         auto fragmentValueObj = fragmentValue.As<v8::Object>();
         fragment = new CanvasFragmentState{};
 
@@ -1532,9 +1532,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
             v8::Local<v8::Value> writeMaskVal;
 
-            state->Get(context, ConvertToV8String(isolate, "writeMask")).ToLocal(&writeMaskVal);
+            auto hasWriteMask = state->Get(context, ConvertToV8String(isolate, "writeMask")).ToLocal(&writeMaskVal);
 
-            if (!writeMaskVal.IsEmpty() && writeMaskVal->IsUint32()) {
+            if (hasWriteMask && writeMaskVal->IsUint32()) {
                 writeMask = writeMaskVal->Uint32Value(context).FromJust();
             }
 
@@ -1544,9 +1544,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
             v8::Local<v8::Value> blendVal;
 
-            state->Get(context, ConvertToV8String(isolate, "blend")).ToLocal(&blendVal);
+            auto hasBlend = state->Get(context, ConvertToV8String(isolate, "blend")).ToLocal(&blendVal);
 
-            if (!blendVal.IsEmpty() && blendVal->IsObject()) {
+            if (hasBlend && blendVal->IsObject()) {
                 auto blendObj = blendVal.As<v8::Object>();
                 auto alpha = blendObj->Get(context, ConvertToV8String(isolate,
                                                                       "alpha")).ToLocalChecked().As<v8::Object>();
@@ -1638,10 +1638,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         }
 
         v8::Local<v8::Value> constantsVal;
-        fragmentValueObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(
+        auto hasConstants = fragmentValueObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(
                 &constantsVal);
 
-        if (!constantsVal.IsEmpty() && constantsVal->IsMap()) {
+        if (hasConstants && constantsVal->IsMap()) {
             auto constants = constantsVal.As<v8::Map>();
             auto keyValues = constants->AsArray();
             auto length = keyValues->Length();
@@ -1675,11 +1675,11 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
         v8::Local<v8::Value> entryPoint;
-        fragmentValueObj->Get(context, ConvertToV8String(isolate, "entryPoint")).ToLocal(
+        auto hasEntryPoint = fragmentValueObj->Get(context, ConvertToV8String(isolate, "entryPoint")).ToLocal(
                 &entryPoint);
 
 
-        if (!entryPoint.IsEmpty() && entryPoint->IsString()) {
+        if (hasEntryPoint && entryPoint->IsString()) {
             auto ep = v8::String::Utf8Value(isolate, entryPoint);
             char *entry_point = (char *) malloc(ep.length());
             std::strcpy(entry_point, *ep);
@@ -1707,7 +1707,6 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
     auto label = GPULabel(isolate, labelVal);
 
-
     descriptor.label = *label;
 
 
@@ -1738,13 +1737,13 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> multisampleValue;
-    options->Get(context, ConvertToV8String(isolate, "multisample")).ToLocal(
+    auto hasMultisample = options->Get(context, ConvertToV8String(isolate, "multisample")).ToLocal(
             &multisampleValue);
 
 
     CanvasMultisampleState *multisample = nullptr;
 
-    if (!multisampleValue.IsEmpty() && multisampleValue->IsObject()) {
+    if (hasMultisample && multisampleValue->IsObject()) {
         auto multisampleObj = multisampleValue.As<v8::Object>();
         multisample = new CanvasMultisampleState{};
         multisample->alpha_to_coverage_enabled = false;
@@ -1755,25 +1754,25 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         v8::Local<v8::Value> count;
         v8::Local<v8::Value> mask;
 
-        multisampleObj->Get(context, ConvertToV8String(isolate, "alphaToCoverageEnabled")).
+        auto hasAlphaToCoverageEnabled = multisampleObj->Get(context, ConvertToV8String(isolate, "alphaToCoverageEnabled")).
                 ToLocal(&alphaToCoverageEnabled);
 
-        if (!alphaToCoverageEnabled.IsEmpty() && alphaToCoverageEnabled->IsBoolean()) {
+        if (hasAlphaToCoverageEnabled && alphaToCoverageEnabled->IsBoolean()) {
             multisample->alpha_to_coverage_enabled = alphaToCoverageEnabled->BooleanValue(
                     isolate);
         }
 
-        multisampleObj->Get(context, ConvertToV8String(isolate, "count")).
+        auto hasCount = multisampleObj->Get(context, ConvertToV8String(isolate, "count")).
                 ToLocal(&count);
 
-        if (!count.IsEmpty() && count->IsUint32()) {
+        if (hasCount && count->IsUint32()) {
             multisample->count = count.As<v8::Uint32>()->Value();
         }
 
-        multisampleObj->Get(context, ConvertToV8String(isolate, "mask")).
+        auto hasMask = multisampleObj->Get(context, ConvertToV8String(isolate, "mask")).
                 ToLocal(&mask);
 
-        if (!mask.IsEmpty() && mask->IsNumber()) {
+        if (hasMask && mask->IsNumber()) {
             // todo verify mask
             auto maskValue = mask.As<v8::Number>()->Value();
             multisample->mask = (uint64_t) maskValue;
@@ -1786,13 +1785,13 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> primitiveValue;
-    options->Get(context, ConvertToV8String(isolate, "primitive")).ToLocal(
+    auto hasPrimitive = options->Get(context, ConvertToV8String(isolate, "primitive")).ToLocal(
             &primitiveValue);
 
 
     CanvasPrimitiveState *primitive = nullptr;
 
-    if (!primitiveValue.IsEmpty() && primitiveValue->IsObject()) {
+    if (hasPrimitive && primitiveValue->IsObject()) {
         auto primitiveObj = primitiveValue.As<v8::Object>();
         primitive = new CanvasPrimitiveState{};
 
@@ -1968,7 +1967,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> vertexValue;
-    options->Get(context, ConvertToV8String(isolate, "vertex")).ToLocal(
+   auto hasVertex = options->Get(context, ConvertToV8String(isolate, "vertex")).ToLocal(
             &vertexValue);
 
 
@@ -1978,7 +1977,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
     std::vector<std::vector<CanvasVertexAttribute>> attributes;
 
-    if (!vertexValue.IsEmpty() && vertexValue->IsObject()) {
+    if (hasVertex && vertexValue->IsObject()) {
         auto vertexObj = vertexValue.As<v8::Object>();
         vertex = new CanvasVertexState{};
 
@@ -1990,9 +1989,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         vertex->module = module->GetShaderModule();
 
         v8::Local<v8::Value> constantsVal;
-        vertexObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(&constantsVal);
+        auto hasConstants = vertexObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(&constantsVal);
 
-        if (!constantsVal.IsEmpty() && constantsVal->IsMap()) {
+        if (hasConstants && constantsVal->IsMap()) {
             auto constants = constantsVal.As<v8::Map>();
             auto keyValues = constants->AsArray();
             auto len = keyValues->Length();
@@ -2027,10 +2026,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         }
 
         v8::Local<v8::Value> buffersVal;
-        vertexObj->Get(context, ConvertToV8String(isolate, "buffers")).ToLocal(&buffersVal);
+        auto hasBuffers = vertexObj->Get(context, ConvertToV8String(isolate, "buffers")).ToLocal(&buffersVal);
 
         uint64_t stride = 0;
-        if (!buffersVal.IsEmpty() && buffersVal->IsArray()) {
+        if (hasBuffers && buffersVal->IsArray()) {
             auto buffers = buffersVal.As<v8::Array>();
             auto len = buffers->Length();
 
@@ -2039,10 +2038,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
                 v8::Local<v8::Value> arrayStride;
 
-                buffer->Get(context, ConvertToV8String(isolate, "arrayStride")).ToLocal(
+                auto hasArrayStride = buffer->Get(context, ConvertToV8String(isolate, "arrayStride")).ToLocal(
                         &arrayStride);
 
-                if (!arrayStride.IsEmpty() && arrayStride->IsNumber()) {
+                if (hasArrayStride && arrayStride->IsNumber()) {
                     stride = (uint64_t) arrayStride.As<v8::Number>()->Value();
                 }
 
@@ -2050,10 +2049,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
                 v8::Local<v8::Value> attributesValue;
 
-                buffer->Get(context, ConvertToV8String(isolate, "attributes")).ToLocal(
+                auto hasAttributes = buffer->Get(context, ConvertToV8String(isolate, "attributes")).ToLocal(
                         &attributesValue);
 
-                if (!attributesValue.IsEmpty() && attributesValue->IsArray()) {
+                if (hasAttributes && attributesValue->IsArray()) {
                     auto attributes_array = attributesValue.As<v8::Array>();
                     auto attributes_len = attributes_array->Length();
 
@@ -2144,6 +2143,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
     }
 
 
+
     auto pipeline = canvas_native_webgpu_device_create_render_pipeline(ptr->GetGPUDevice(),
                                                                        &descriptor);
 

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

@@ -428,30 +428,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 +600,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>());