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

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

@@ -28,7 +28,7 @@ void GPUCommandEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUCommandEncoder"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUCommandEncoder"), func).FromJust();
 }
 
 GPUCommandEncoderImpl *GPUCommandEncoderImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -257,45 +257,18 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
             v8::Local<v8::Value> clearValueVal;
             colorAttachment->Get(context, ConvertToV8String(isolate, "clearValue")).ToLocal(
                     &clearValueVal);
-            auto clearValue = CanvasColor{0, 0, 0, 0};
-            if (!clearValueVal.IsEmpty() && clearValueVal->IsObject()) {
-                auto clearValueObj = clearValueVal.As<v8::Object>();
-
-                v8::Local<v8::Value> r;
-                v8::Local<v8::Value> g;
-                v8::Local<v8::Value> b;
-                v8::Local<v8::Value> a;
-
-                clearValueObj->Get(context, ConvertToV8String(isolate, "r")).ToLocal(&r);
-                clearValueObj->Get(context, ConvertToV8String(isolate, "g")).ToLocal(&g);
-                clearValueObj->Get(context, ConvertToV8String(isolate, "b")).ToLocal(&b);
-                clearValueObj->Get(context, ConvertToV8String(isolate, "a")).ToLocal(&a);
-
-                if (!r.IsEmpty() && r->IsNumber()) {
-                    clearValue.r = r.As<v8::Number>()->Value();
-                }
-
-                if (!g.IsEmpty() && g->IsNumber()) {
-                    clearValue.g = g.As<v8::Number>()->Value();
-                }
-
-
-                if (!b.IsEmpty() && b->IsNumber()) {
-                    clearValue.b = b.As<v8::Number>()->Value();
-                }
-
-                if (!a.IsEmpty() && a->IsNumber()) {
-                    clearValue.a = a.As<v8::Number>()->Value();
-                }
-            }
 
+            auto clearValue = ParseColor(isolate, clearValueVal);
 
-            auto viewVal = colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                                           "view")).ToLocalChecked();
-
-            auto view = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
-
+            v8::Local<v8::Value> viewVal;
+            colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                            "view")).ToLocal(&viewVal);
 
+            const CanvasGPUTextureView *view = nullptr;
+         
+            auto viewPtr = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
+            view = viewPtr->GetTextureView();
+            
             const CanvasGPUTextureView *resolve_target = nullptr;
 
             v8::Local<v8::Value> resolve_target_val;
@@ -313,34 +286,37 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
             // default
             CanvasLoadOp load = CanvasLoadOp::CanvasLoadOpClear;
             CanvasStoreOp store = CanvasStoreOp::CanvasStoreOpStore;
-            auto loadVal = colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                                           "loadOp")).ToLocalChecked();
-
-            if (loadVal->IsUint32()) {
-                load = (CanvasLoadOp) loadVal->Uint32Value(
-                        context).ToChecked();
-            } else if (loadVal->IsString()) {
-                auto val = ConvertFromV8String(isolate, loadVal);
-                if (val == "clear") {
-                    load = CanvasLoadOp::CanvasLoadOpClear;
-                } else if (val == "load") {
-                    load = CanvasLoadOp::CanvasLoadOpLoad;
+            v8::Local<v8::Value> loadVal;
+
+            if(colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                               "loadOp")).ToLocal(&loadVal)){
+                if (loadVal->IsUint32()) {
+                    load = (CanvasLoadOp) loadVal->Uint32Value(
+                            context).ToChecked();
+                } else if (loadVal->IsString()) {
+                    auto val = ConvertFromV8String(isolate, loadVal);
+                    if (val == "clear") {
+                        load = CanvasLoadOp::CanvasLoadOpClear;
+                    } else if (val == "load") {
+                        load = CanvasLoadOp::CanvasLoadOpLoad;
+                    }
                 }
             }
-
-
-            auto storeVal = colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                                            "storeOp")).ToLocalChecked();
-
-            if (!storeVal.IsEmpty() && storeVal->IsUint32()) {
-                store = (CanvasStoreOp) storeVal->Uint32Value(
-                        context).ToChecked();
-            } else if (storeVal->IsString()) {
-                auto val = ConvertFromV8String(isolate, storeVal);
-                if (val == "discard") {
-                    store = CanvasStoreOp::CanvasStoreOpDiscard;
-                } else if (val == "store") {
-                    store = CanvasStoreOp::CanvasStoreOpStore;
+    
+         
+            v8::Local<v8::Value> storeVal;
+            if(colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                               "storeOp")).ToLocal(&storeVal)){
+                if (storeVal->IsUint32()) {
+                    store = (CanvasStoreOp) storeVal->Uint32Value(
+                            context).ToChecked();
+                } else if (storeVal->IsString()) {
+                    auto val = ConvertFromV8String(isolate, storeVal);
+                    if (val == "discard") {
+                        store = CanvasStoreOp::CanvasStoreOpDiscard;
+                    } else if (val == "store") {
+                        store = CanvasStoreOp::CanvasStoreOpStore;
+                    }
                 }
             }
 
@@ -352,7 +328,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
             };
 
             auto attachment = CanvasRenderPassColorAttachment{
-                    view->GetTextureView(),
+                    view,
                     resolve_target,
                     channel
             };
@@ -362,8 +338,8 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
         }
 
 
+        // todo add when supported
         v8::Local<v8::Value> maxDrawCountVal;
-
         desc->Get(context, ConvertToV8String(isolate, "maxDrawCount")).ToLocal(&maxDrawCountVal);
 
 
@@ -376,8 +352,164 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
 
         if (!depthStencilAttachmentVal.IsEmpty() && depthStencilAttachmentVal->IsObject()) {
             auto depthStencilAttachmentObj = depthStencilAttachmentVal.As<v8::Object>();
-        }
+            depthStencilAttachment = new CanvasRenderPassDepthStencilAttachment{};
+
+
+            v8::Local<v8::Value> viewVal;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "view")).ToLocal(&viewVal);
 
+            auto viewPtr = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
+            depthStencilAttachment->view = viewPtr->GetTextureView();
+
+
+            v8::Local<v8::Value> depthClearValue;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "depthClearValue")).ToLocal(
+                    &depthClearValue);
+
+            depthStencilAttachment->depth_clear_value = 0;
+
+            if (!depthClearValue.IsEmpty() && depthClearValue->IsNumber()) {
+                depthStencilAttachment->depth_clear_value = (float) depthClearValue->NumberValue(
+                        context).FromJust();
+            }
+
+            v8::Local<v8::Value> depthLoadOp;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "depthLoadOp")).ToLocal(
+                    &depthLoadOp);
+
+            depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
+                CanvasOptionalLoadOpNone
+            };
+
+            if (!depthLoadOp.IsEmpty() && depthLoadOp->IsString()) {
+                auto value = ConvertFromV8String(isolate, depthLoadOp);
+                if (value == "load") {
+                    depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
+                        CanvasOptionalLoadOpSome,
+                        CanvasLoadOpLoad
+                    };
+                } else if (value == "clear") {
+                    depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
+                        CanvasOptionalLoadOpSome,
+                        CanvasLoadOpClear
+                    };
+                }
+            }
+
+
+            v8::Local<v8::Value> depthStoreOp;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "depthStoreOp")).ToLocal(
+                    &depthStoreOp);
+
+            depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
+                CanvasOptionalStoreOpNone
+            };
+
+            if (!depthStoreOp.IsEmpty() && depthStoreOp->IsString()) {
+                auto value = ConvertFromV8String(isolate, depthStoreOp);
+                if (value == "store") {
+                    depthStencilAttachment->depth_store_op = depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
+                        CanvasOptionalStoreOpSome,
+                        CanvasStoreOpStore
+                    };
+                } else if (value == "discard") {
+                    depthStencilAttachment->depth_store_op = depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
+                        CanvasOptionalStoreOpSome,
+                        CanvasStoreOpDiscard
+                    };
+                }
+            }
+
+
+            v8::Local<v8::Value> depthReadOnly;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "depthReadOnly")).ToLocal(
+                    &depthReadOnly);
+
+            depthStencilAttachment->depth_read_only = false;
+            if (!depthReadOnly.IsEmpty() && depthReadOnly->IsBoolean()) {
+                depthStencilAttachment->depth_read_only = depthReadOnly->BooleanValue(isolate);
+            }
+
+
+            v8::Local<v8::Value> stencilClearValue;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "stencilClearValue")).ToLocal(
+                    &stencilClearValue);
+
+            depthStencilAttachment->stencil_clear_value = 0;
+
+            if (!stencilClearValue.IsEmpty() && stencilClearValue->IsUint32()) {
+                depthStencilAttachment->stencil_clear_value = stencilClearValue->Uint32Value(
+                        context).FromJust();
+            }
+
+
+            v8::Local<v8::Value> stencilLoadOp;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "stencilLoadOp")).ToLocal(
+                    &stencilLoadOp);
+
+            depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
+                CanvasOptionalLoadOpNone
+            };
+
+            if (!stencilLoadOp.IsEmpty() && stencilLoadOp->IsString()) {
+                auto value = ConvertFromV8String(isolate, stencilLoadOp);
+                if (value == "load") {
+                    depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
+                        CanvasOptionalLoadOpSome,
+                        CanvasLoadOpLoad
+                    };
+                } else if (value == "clear") {
+                    depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
+                        CanvasOptionalLoadOpSome,
+                        CanvasLoadOpClear
+                    };
+                }
+            }
+
+
+            v8::Local<v8::Value> stencilStoreOp;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "stencilStoreOp")).ToLocal(
+                    &stencilStoreOp);
+
+            depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
+                CanvasOptionalStoreOpNone
+            };
+
+            if (!stencilStoreOp.IsEmpty() && stencilStoreOp->IsString()) {
+                auto value = ConvertFromV8String(isolate, stencilStoreOp);
+                if (value == "store") {
+                    depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
+                        CanvasOptionalStoreOpSome,
+                        CanvasStoreOpStore
+                    };
+                } else if (value == "discard") {
+                    depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
+                        CanvasOptionalStoreOpSome,
+                        CanvasStoreOpDiscard
+                    };
+                }
+            }
+
+
+            v8::Local<v8::Value> stencilReadOnly;
+            depthStencilAttachmentObj->Get(context, ConvertToV8String(isolate,
+                                                                      "stencilReadOnly")).ToLocal(
+                    &stencilReadOnly);
+
+            depthStencilAttachment->stencil_read_only = false;
+            if (!stencilReadOnly.IsEmpty() && stencilReadOnly->IsBoolean()) {
+                depthStencilAttachment->stencil_read_only = stencilReadOnly->BooleanValue(isolate);
+            }
+
+        }
 
         const CanvasGPUQuerySet *occlusion_query_set = nullptr;
         v8::Local<v8::Value> occlusionQuerySetVal;
@@ -386,8 +518,8 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
         desc->Get(context, ConvertToV8String(isolate, "occlusionQuerySet")).ToLocal(
                 &occlusionQuerySetVal);
 
-
-        if (!occlusionQuerySetVal.IsEmpty() && occlusionQuerySetVal->IsObject()) {
+        
+        if (GetNativeType(occlusionQuerySetVal) == NativeType::GPUQuerySet) {
             auto occlusionQuerySet = GPUQuerySetImpl::GetPointer(
                     occlusionQuerySetVal.As<v8::Object>());
             occlusion_query_set = occlusionQuerySet->GetQuerySet();
@@ -410,7 +542,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &querySetVal);
 
 
-            if (!querySetVal.IsEmpty() && querySetVal->IsObject()) {
+            if (GetNativeType(querySetVal) == NativeType::GPUQuerySet) {
                 auto queryPtr = GPUQuerySetImpl::GetPointer(querySetVal.As<v8::Object>());
                 if (queryPtr != nullptr) {
                     querySet = queryPtr->GetQuerySet();
@@ -451,6 +583,10 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                 querySet, beginningOfPassWriteIndex, endOfPassWriteIndex
         );
 
+        if (depthStencilAttachment != nullptr) {
+            delete depthStencilAttachment;
+        }
+
 
     }
 
@@ -970,10 +1106,9 @@ void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &ar
     if (descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
         v8::Local<v8::Value> labelVal;
-        desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
-        if (!labelVal.IsEmpty() && labelVal->IsString()) {
+        didSet = desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
+        if (didSet && labelVal->IsString()) {
             label = ConvertFromV8String(isolate, labelVal);
-            didSet = true;
         }
     }
 

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

@@ -377,6 +377,8 @@ void GPUDeviceImpl::CreateBindGroup(const v8::FunctionCallbackInfo<v8::Value> &a
     char *label = nullptr;
 
     auto optionsVal = args[0];
+    
+    std::vector<CanvasBindGroupEntry> entries;
 
     if (optionsVal->IsObject()) {
         auto options = optionsVal.As<v8::Object>();
@@ -401,7 +403,6 @@ void GPUDeviceImpl::CreateBindGroup(const v8::FunctionCallbackInfo<v8::Value> &a
             }
         }
 
-        std::vector<CanvasBindGroupEntry> entries;
 
         v8::Local<v8::Value> entriesVal;
         options->Get(context, ConvertToV8String(isolate, "entries")).ToLocal(&entriesVal);
@@ -466,7 +467,8 @@ void GPUDeviceImpl::CreateBindGroup(const v8::FunctionCallbackInfo<v8::Value> &a
                                         int64_t offset = -1;
 
                                         v8::Local<v8::Value> offsetVal;
-                                        bufferObj->Get(context,
+                                        
+                                        resourceObj->Get(context,
                                                        ConvertToV8String(isolate,
                                                                          "offset")).ToLocal(
                                                 &offsetVal);
@@ -478,9 +480,9 @@ void GPUDeviceImpl::CreateBindGroup(const v8::FunctionCallbackInfo<v8::Value> &a
                                         int64_t size = -1;
 
                                         v8::Local<v8::Value> sizeVal;
-                                        bufferObj->Get(context,
+                                        resourceObj->Get(context,
                                                        ConvertToV8String(isolate, "size")).ToLocal(
-                                                &offsetVal);
+                                                &sizeVal);
                                         if (!sizeVal.IsEmpty() && sizeVal->IsNumber()) {
                                             size = (int64_t) sizeVal->NumberValue(
                                                     context).ToChecked();
@@ -595,7 +597,7 @@ void GPUDeviceImpl::CreateBindGroupLayout(const v8::FunctionCallbackInfo<v8::Val
 
                         v8::Local<v8::Value> hasDynamicOffsetVal;
                         bufferObj->Get(context,
-                                       ConvertToV8String(isolate, "hasDynamicOffset ")).ToLocal(
+                                       ConvertToV8String(isolate, "hasDynamicOffset")).ToLocal(
                                 &hasDynamicOffsetVal);
 
 
@@ -607,7 +609,7 @@ void GPUDeviceImpl::CreateBindGroupLayout(const v8::FunctionCallbackInfo<v8::Val
 
                         v8::Local<v8::Value> minBindingSizeVal;
                         bufferObj->Get(context,
-                                       ConvertToV8String(isolate, "minBindingSize ")).ToLocal(
+                                       ConvertToV8String(isolate, "minBindingSize")).ToLocal(
                                 &minBindingSizeVal);
 
 
@@ -1086,9 +1088,10 @@ void GPUDeviceImpl::CreateComputePipeline(const v8::FunctionCallbackInfo<v8::Val
 
                     if (!keyVal.IsEmpty() && keyVal->IsString() && !valueVal.IsEmpty() &&
                         valueVal->IsNumber()) {
+                        auto val = ConvertFromV8String(isolate, keyVal);
                         canvas_native_webgpu_constants_insert(
                                 store,
-                                *v8::String::Utf8Value(isolate, keyVal),
+                                val.c_str(),
                                 valueVal.As<v8::Number>()->Value()
                         );
                     }
@@ -1412,9 +1415,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
         stencilObj->Get(context, ConvertToV8String(isolate, "format")).ToLocal(&formatValue);
         if (!formatValue.IsEmpty() && formatValue->IsString()) {
-            auto val = *v8::String::Utf8Value(isolate, formatValue);
+            auto val = ConvertFromV8String(isolate, formatValue);
             auto format = canvas_native_webgpu_enum_string_to_gpu_texture(
-                    val);
+                    val.c_str());
             if (format.tag ==
                 CanvasOptionalGPUTextureFormat_Tag::CanvasOptionalGPUTextureFormatSome) {
                 stencil->format = format.some;
@@ -1434,8 +1437,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         stencilObj->Get(context, ConvertToV8String(isolate, "depthBiasClamp")).ToLocal(
                 &depthBiasClampVal);
 
-        if (!depthBiasClampVal.IsEmpty() && depthBiasClampVal->IsInt32()) {
-            stencil->depth_bias_clamp = depthBiasClampVal->Int32Value(context).FromJust();
+        if (!depthBiasClampVal.IsEmpty() && depthBiasClampVal->IsNumber()) {
+            stencil->depth_bias_clamp = (float)depthBiasClampVal->NumberValue(context).FromJust();
         }
 
 
@@ -1443,8 +1446,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         stencilObj->Get(context, ConvertToV8String(isolate, "depthBiasSlopeScale")).ToLocal(
                 &depthBiasSlopeScaleVal);
 
-        if (!depthBiasSlopeScaleVal.IsEmpty() && depthBiasSlopeScaleVal->IsInt32()) {
-            stencil->depth_bias_slope_scale = depthBiasSlopeScaleVal->Int32Value(
+        if (!depthBiasSlopeScaleVal.IsEmpty() && depthBiasSlopeScaleVal->IsNumber()) {
+            stencil->depth_bias_slope_scale = (float)depthBiasSlopeScaleVal->NumberValue(
                     context).FromJust();
         }
 
@@ -1570,6 +1573,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         if (!stencilWriteMaskVal.IsEmpty() && stencilWriteMaskVal->IsUint32()) {
             stencil->stencil_write_mask = stencilWriteMaskVal->Uint32Value(context).FromJust();
         }
+        
+        descriptor.depth_stencil = stencil;
 
     }
 
@@ -1907,6 +1912,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
                     case 2:
                         primitive->cull_mode = CanvasCullMode::CanvasCullModeBack;
                         break;
+                    default:
+                        break;
                 }
             } else if (cullModeValue->IsString()) {
 
@@ -2059,7 +2066,6 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
     std::vector<std::vector<CanvasVertexAttribute>> attributes;
 
-
     if (!vertexValue.IsEmpty() && vertexValue->IsObject()) {
         auto vertexObj = vertexValue.As<v8::Object>();
         vertex = new CanvasVertexState{};
@@ -2256,6 +2262,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         }
 
     }
+    
+    if(descriptor.depth_stencil != nullptr){
+        delete descriptor.depth_stencil;
+    }
 
 
     if (pipeline != nullptr) {
@@ -2599,10 +2609,9 @@ void GPUDeviceImpl::CreateTexture(const v8::FunctionCallbackInfo<v8::Value> &arg
 
 
         v8::Local<v8::Value> formatVal;
-        options->Get(context, ConvertToV8String(isolate, "format")).ToLocal(
-                &formatVal);
 
-        if (formatVal->IsString()) {
+        if (options->Get(context, ConvertToV8String(isolate, "format")).ToLocal(
+                                                                                &formatVal) && formatVal->IsString()) {
             auto format = ConvertFromV8String(isolate, formatVal);
 
             // todo use enum

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,7 +54,6 @@ v8::Local<v8::FunctionTemplate> GPURenderPassEncoderImpl::GetCtor(v8::Isolate *i
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
-
     tmpl->Set(
             ConvertToV8String(isolate, "beginOcclusionQuery"),
             v8::FunctionTemplate::New(isolate, &BeginOcclusionQuery));
@@ -66,7 +66,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 +74,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));
@@ -173,7 +170,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 +205,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();
@@ -415,11 +415,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 +435,6 @@ void GPURenderPassEncoderImpl::SetIndexBuffer(const v8::FunctionCallbackInfo<v8:
     }
 
     auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
 
     auto bufferVal = args[0];
     auto indexFormatVal = args[1];
@@ -482,41 +481,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>();
+    if (colorVal->IsObject() || colorVal->IsArray()) {
 
-        v8::Local<v8::Value> r;
-        v8::Local<v8::Value> g;
-        v8::Local<v8::Value> b;
-        v8::Local<v8::Value> a;
+        auto color = ParseColor(isolate, colorVal);
 
-        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 (!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 +501,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 +567,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();
         }