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

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

@@ -100,7 +100,7 @@ GPUAdapterImpl::GetFeatures(v8::Local<v8::Name> name,
             }
 
         }
-        canvas_native_string_buffer_destroy(features);
+        canvas_native_string_buffer_release(features);
 
         info.GetReturnValue().Set(map);
 

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

@@ -270,7 +270,7 @@ void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Va
             auto formats = v8::Array::New(isolate, (int) formats_len);
             for (int i = 0; i < formats_len; i++) {
                 auto format = canvas_native_string_buffer_get_value_at(cap->formats, i);
-                formats->Set(context, i, ConvertToV8String(isolate, format));
+                formats->Set(context, i, ConvertToV8String(isolate, format)).FromJust();
                 canvas_native_string_destroy(format);
             }
 
@@ -280,7 +280,7 @@ void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Va
 
             for (int i = 0; i < present_modes_len; i++) {
                 auto mode = canvas_native_string_buffer_get_value_at(cap->present_modes, i);
-                present_modes->Set(context, i, ConvertToV8String(isolate, mode));
+                present_modes->Set(context, i, ConvertToV8String(isolate, mode)).FromJust();
                 canvas_native_string_destroy(mode);
             }
 
@@ -290,15 +290,15 @@ void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Va
 
             for (int i = 0; i < alpha_modes_len; i++) {
                 auto mode = canvas_native_string_buffer_get_value_at(cap->alpha_modes, i);
-                alpha_modes->Set(context, i, ConvertToV8String(isolate, mode));
+                alpha_modes->Set(context, i, ConvertToV8String(isolate, mode)).FromJust();
                 canvas_native_string_destroy(mode);
             }
 
-            ret->Set(context, ConvertToV8String(isolate, "format"), formats);
-            ret->Set(context, ConvertToV8String(isolate, "presentModes"), present_modes);
-            ret->Set(context, ConvertToV8String(isolate, "alphaModes"), alpha_modes);
+            ret->Set(context, ConvertToV8String(isolate, "format"), formats).FromJust();
+            ret->Set(context, ConvertToV8String(isolate, "presentModes"), present_modes).FromJust();
+            ret->Set(context, ConvertToV8String(isolate, "alphaModes"), alpha_modes).FromJust();
             ret->Set(context, ConvertToV8String(isolate, "usages"),
-                     v8::Uint32::NewFromUnsigned(isolate, cap->usages));
+                     v8::Uint32::NewFromUnsigned(isolate, cap->usages)).FromJust();
 
             canvas_native_webgpu_struct_surface_capabilities_release(cap);
 
@@ -309,9 +309,9 @@ void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Va
 
     }
 
-    ret->Set(context, ConvertToV8String(isolate, "format"), v8::Array::New(isolate));
-    ret->Set(context, ConvertToV8String(isolate, "presentModes"), v8::Array::New(isolate));
-    ret->Set(context, ConvertToV8String(isolate, "alphaModes"), v8::Array::New(isolate));
-    ret->Set(context, ConvertToV8String(isolate, "usages"), v8::Uint32::New(isolate, 0));
+    ret->Set(context, ConvertToV8String(isolate, "format"), v8::Array::New(isolate)).FromJust();
+    ret->Set(context, ConvertToV8String(isolate, "presentModes"), v8::Array::New(isolate)).FromJust();
+    ret->Set(context, ConvertToV8String(isolate, "alphaModes"), v8::Array::New(isolate)).FromJust();
+    ret->Set(context, ConvertToV8String(isolate, "usages"), v8::Uint32::New(isolate, 0)).FromJust();
     args.GetReturnValue().Set(ret);
 }

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

@@ -248,13 +248,13 @@ GPUDeviceImpl::GetFeatures(v8::Local<v8::Name> name,
         for (int i = 0; i < len; ++i) {
             auto item = canvas_native_string_buffer_get_value_at(features, i);
             if (item != nullptr) {
-                auto keyValue = ConvertToV8OneByteString(isolate, (char *) item);
+                auto keyValue = ConvertToV8String(isolate, (char *) item);
                 map->Set(context, keyValue, keyValue);
                 canvas_native_string_destroy(item);
             }
 
         }
-        canvas_native_string_buffer_destroy(features);
+        canvas_native_string_buffer_release(features);
 
         info.GetReturnValue().Set(map);
 
@@ -378,6 +378,8 @@ void GPUDeviceImpl::CreateBindGroup(const v8::FunctionCallbackInfo<v8::Value> &a
 
     auto optionsVal = args[0];
 
+    std::vector<CanvasBindGroupEntry> entries;
+
     if (optionsVal->IsObject()) {
         auto options = optionsVal.As<v8::Object>();
         v8::Local<v8::Value> labelVal;
@@ -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()
                         );
                     }
@@ -1231,7 +1234,6 @@ void GPUDeviceImpl::CreateQuerySet(const v8::FunctionCallbackInfo<v8::Value> &ar
         label = *v8::String::Utf8Value(isolate, labelVal);
     }
 
-
     v8::Local<v8::Value> typeVal;
     options->Get(context, ConvertToV8String(isolate, "type")).ToLocal(&labelVal);
 
@@ -1412,9 +1414,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 +1436,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 +1445,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();
         }
 
@@ -1571,6 +1573,8 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
             stencil->stencil_write_mask = stencilWriteMaskVal->Uint32Value(context).FromJust();
         }
 
+        descriptor.depth_stencil = stencil;
+
     }
 
 
@@ -1907,6 +1911,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 +2065,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{};
@@ -2257,6 +2262,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
     }
 
+    if(descriptor.depth_stencil != nullptr){
+        delete descriptor.depth_stencil;
+    }
+
 
     if (pipeline != nullptr) {
         auto ret = GPURenderPipelineImpl::NewInstance(isolate, new GPURenderPipelineImpl(pipeline));
@@ -2599,10 +2608,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/GPUDeviceImpl.h

@@ -11,7 +11,7 @@
 
 class GPUDeviceImpl : ObjectWrapperImpl {
 public:
-    GPUDeviceImpl(const CanvasGPUDevice *device);
+    explicit GPUDeviceImpl(const CanvasGPUDevice *device);
 
     ~GPUDeviceImpl() {
         canvas_native_webgpu_device_release(this->device_);

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

@@ -180,7 +180,7 @@ void GPUImpl::__GetPointer(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto isolate = args.GetIsolate();
 
-    auto pointer = (intptr_t *) ptr->GetGPUInstance();
-    auto ret = std::to_string((intptr_t) pointer);
+    auto pointer = canvas_native_webgpu_get_pointer_addr(ptr->GetGPUInstance());
+    auto ret = std::to_string(pointer);
     args.GetReturnValue().Set(ConvertToV8String(isolate, ret));
 }