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

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

@@ -13,7 +13,7 @@
 #include "GPUTextureImpl.h"
 
 GPUCommandEncoderImpl::GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *encoder) : encoder_(
-        encoder) {}
+                                                                                                encoder) {}
 
 const CanvasGPUCommandEncoder *GPUCommandEncoderImpl::GetEncoder() {
     return this->encoder_;
@@ -23,12 +23,12 @@ void GPUCommandEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate
     v8::Locker locker(isolate);
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
-
+    
     auto ctor = GetCtor(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) {
@@ -45,165 +45,185 @@ v8::Local<v8::FunctionTemplate> GPUCommandEncoderImpl::GetCtor(v8::Isolate *isol
     if (ctor != nullptr) {
         return ctor->Get(isolate);
     }
-
+    
     v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
     ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
     ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPUCommandEncoder"));
-
+    
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
-
-
+    
+    tmpl->SetLazyDataProperty(
+                              ConvertToV8String(isolate, "label"),
+                              GetLabel
+                              );
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "beginComputePass"),
-            v8::FunctionTemplate::New(isolate, &BeginComputePass));
-
+              ConvertToV8String(isolate, "beginComputePass"),
+              v8::FunctionTemplate::New(isolate, &BeginComputePass));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "beginRenderPass"),
-            v8::FunctionTemplate::New(isolate, &BeginRenderPass));
-
+              ConvertToV8String(isolate, "beginRenderPass"),
+              v8::FunctionTemplate::New(isolate, &BeginRenderPass));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "clearBuffer"),
-            v8::FunctionTemplate::New(isolate, &ClearBuffer));
-
+              ConvertToV8String(isolate, "clearBuffer"),
+              v8::FunctionTemplate::New(isolate, &ClearBuffer));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "copyBufferToBuffer"),
-            v8::FunctionTemplate::New(isolate, &CopyBufferToBuffer));
-
+              ConvertToV8String(isolate, "copyBufferToBuffer"),
+              v8::FunctionTemplate::New(isolate, &CopyBufferToBuffer));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "copyBufferToTexture"),
-            v8::FunctionTemplate::New(isolate, &CopyBufferToTexture));
-
+              ConvertToV8String(isolate, "copyBufferToTexture"),
+              v8::FunctionTemplate::New(isolate, &CopyBufferToTexture));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "copyTextureToBuffer"),
-            v8::FunctionTemplate::New(isolate, &CopyTextureToBuffer));
-
+              ConvertToV8String(isolate, "copyTextureToBuffer"),
+              v8::FunctionTemplate::New(isolate, &CopyTextureToBuffer));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "copyTextureToTexture"),
-            v8::FunctionTemplate::New(isolate, &CopyTextureToTexture));
-
+              ConvertToV8String(isolate, "copyTextureToTexture"),
+              v8::FunctionTemplate::New(isolate, &CopyTextureToTexture));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "finish"),
-            v8::FunctionTemplate::New(isolate, &Finish));
-
+              ConvertToV8String(isolate, "finish"),
+              v8::FunctionTemplate::New(isolate, &Finish));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "insertDebugMarker"),
-            v8::FunctionTemplate::New(isolate, &InsertDebugMarker));
-
+              ConvertToV8String(isolate, "insertDebugMarker"),
+              v8::FunctionTemplate::New(isolate, &InsertDebugMarker));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "popDebugGroup"),
-            v8::FunctionTemplate::New(isolate, &PopDebugGroup));
-
+              ConvertToV8String(isolate, "popDebugGroup"),
+              v8::FunctionTemplate::New(isolate, &PopDebugGroup));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "pushDebugGroup"),
-            v8::FunctionTemplate::New(isolate, &PushDebugGroup));
-
+              ConvertToV8String(isolate, "pushDebugGroup"),
+              v8::FunctionTemplate::New(isolate, &PushDebugGroup));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "resolveQuerySet"),
-            v8::FunctionTemplate::New(isolate, &ResolveQuerySet));
-
+              ConvertToV8String(isolate, "resolveQuerySet"),
+              v8::FunctionTemplate::New(isolate, &ResolveQuerySet));
+    
     tmpl->Set(
-            ConvertToV8String(isolate, "writeTimestamp"),
-            v8::FunctionTemplate::New(isolate, &WriteTimestamp));
-
-
+              ConvertToV8String(isolate, "writeTimestamp"),
+              v8::FunctionTemplate::New(isolate, &WriteTimestamp));
+    
+    
     cache->GPUCommandEncoderTmpl =
-            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
 
+void
+GPUCommandEncoderImpl::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_command_encoder_get_label(ptr->encoder_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                                  ConvertToV8String(info.GetIsolate(), label)
+                                  );
+        canvas_native_string_destroy(label);
+        return;
+    }
+    
+    info.GetReturnValue().SetEmptyString();
+}
+
 
 void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
+    
     auto descVal = args[0];
-
+    
     const CanvasGPUComputePassEncoder *pass;
-
+    
     if (!descVal->IsNullOrUndefined() && descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
-
-
+        
+        
         v8::Local<v8::Value> labelVal;
         desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
-
-        char *label = nullptr;
-
-        if (!labelVal.IsEmpty() && labelVal->IsString()) {
-            label = *v8::String::Utf8Value(isolate, labelVal);
-        }
-
+        
+        std::string label = ConvertFromV8String(isolate, labelVal);
+        
         const CanvasGPUQuerySet *querySet = nullptr;
+        
         int32_t beginningOfPassWriteIndex = -1;
-
+        
         int32_t endOfPassWriteIndex = -1;
-
-
+        
+        
         v8::Local<v8::Value> timestampWritesVal;
-        desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
-                &timestampWritesVal);
-
-
-        if (!timestampWritesVal.IsEmpty() && timestampWritesVal->IsObject()) {
+        
+        auto success = desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
+                                                                                                 &timestampWritesVal);
+        if (success && timestampWritesVal->IsObject()) {
             auto timestampWrites = timestampWritesVal.As<v8::Object>();
-
+            
             v8::Local<v8::Value> querySetVal;
-            timestampWrites->Get(context, ConvertToV8String(isolate, "querySet")).ToLocal(
-                    &querySetVal);
-
-
-            if (!querySetVal.IsEmpty() && querySetVal->IsObject()) {
+            success = timestampWrites->Get(context, ConvertToV8String(isolate, "querySet")).ToLocal(
+                                                                                          &querySetVal);
+            
+            
+            if (success && querySetVal->IsObject()) {
                 auto queryPtr = GPUQuerySetImpl::GetPointer(querySetVal.As<v8::Object>());
                 if (queryPtr != nullptr) {
                     querySet = queryPtr->GetQuerySet();
                 }
             }
-
+            
             v8::Local<v8::Value> beginningOfPassWriteIndexVal;
-
-
+            
+            
             v8::Local<v8::Value> endOfPassWriteIndexVal;
-
-
-            timestampWrites->Get(context,
+            
+            
+            success = timestampWrites->Get(context,
                                  ConvertToV8String(isolate, "beginningOfPassWriteIndex")).ToLocal(
-                    &beginningOfPassWriteIndexVal);
-
-            timestampWrites->Get(context,
-                                 ConvertToV8String(isolate, "endOfPassWriteIndex")).ToLocal(
-                    &endOfPassWriteIndexVal);
-
-
-            if (beginningOfPassWriteIndexVal->IsInt32()) {
+                                                                                                  &beginningOfPassWriteIndexVal);
+            
+            if (success && beginningOfPassWriteIndexVal->IsInt32()) {
                 beginningOfPassWriteIndex = beginningOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
-
-            if (endOfPassWriteIndexVal->IsInt32()) {
+            
+            success = timestampWrites->Get(context,
+                                 ConvertToV8String(isolate, "endOfPassWriteIndex")).ToLocal(
+                                                                                            &endOfPassWriteIndexVal);
+            
+            
+            if (success && endOfPassWriteIndexVal->IsInt32()) {
                 endOfPassWriteIndex = endOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
         }
-
-
+        
+        
         pass = canvas_native_webgpu_command_encoder_begin_compute_pass(ptr->GetEncoder(),
-                                                                       querySet, label,
+                                                                       querySet, label.c_str(),
                                                                        beginningOfPassWriteIndex,
                                                                        endOfPassWriteIndex);
-
-
+        
+        
     } else {
         pass = canvas_native_webgpu_command_encoder_begin_compute_pass(ptr->GetEncoder(),
                                                                        nullptr, nullptr, -1,
                                                                        -1);
-
+        
     }
-
-
+    
+    
     if (pass != nullptr) {
         auto value = new GPUComputePassEncoderImpl(pass);
         auto ret = GPUComputePassEncoderImpl::NewInstance(isolate, value);
@@ -211,7 +231,7 @@ void GPUCommandEncoderImpl::BeginComputePass(const v8::FunctionCallbackInfo<v8::
     } else {
         args.GetReturnValue().SetUndefined();
     }
-
+    
 }
 
 void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -219,242 +239,357 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
+    
     auto descVal = args[0];
-
+    
     const CanvasGPURenderPassEncoder *pass = nullptr;
-
+    
     std::vector<CanvasRenderPassColorAttachment> colorAttachments_;
-
+    
     if (!descVal->IsNullOrUndefined() && descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
-
-
+        
         v8::Local<v8::Value> labelVal;
         desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
-
-        char *label = nullptr;
-
-        if (!labelVal.IsEmpty() && labelVal->IsString()) {
-            label = *v8::String::Utf8Value(isolate, labelVal);
-        }
-
-
+        
+        std::string label = ConvertFromV8String(isolate, labelVal);
+        
+        
         v8::Local<v8::Value> colorAttachmentsVal;
         desc->Get(context, ConvertToV8String(isolate, "colorAttachments")).ToLocal(
-                &colorAttachmentsVal);
-
+                                                                                   &colorAttachmentsVal);
+        
         auto colorAttachments = colorAttachmentsVal.As<v8::Array>();
         auto colorAttachmentsLength = colorAttachments->Length();
-
+        
         for (int i = 0; i < colorAttachmentsLength; i++) {
             auto colorAttachment = colorAttachments->Get(context,
                                                          i).ToLocalChecked().As<v8::Object>();
-
+            
             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();
+                                                                                            &clearValueVal);
+            
+            auto clearValue = ParseColor(isolate, clearValueVal);
+            
+            const CanvasGPUTextureView *view = nullptr;
+            
+            v8::Local<v8::Value> viewVal;
+            
+            
+            if (colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                                "view")).ToLocal(&viewVal)) {
+                auto type = GetNativeType(viewVal);
+                if (type == NativeType::GPUTextureView) {
+                    auto viewPtr = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
+                    view = viewPtr->GetTextureView();
                 }
             }
-
-
-            auto viewVal = colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                                           "view")).ToLocalChecked();
-
-            auto view = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
-
-
-            const CanvasGPUTextureView *resolve_target = nullptr;
-
-            v8::Local<v8::Value> resolve_target_val;
-
+            
+            
+            const CanvasGPUTextureView *resolveTarget = nullptr;
+            
+            v8::Local<v8::Value> resolveTargetVal;
+            
             colorAttachment->Get(context, ConvertToV8String(isolate, "resolveTarget")).ToLocal(
-                    &resolve_target_val);
-
-            auto resolve_target_type = GetNativeType(resolve_target_val);
-
+                                                                                               &resolveTargetVal);
+            
+            auto resolve_target_type = GetNativeType(resolveTargetVal);
+            
             if (resolve_target_type == NativeType::GPUTextureView) {
-                auto res = GPUTextureViewImpl::GetPointer(resolve_target_val.As<v8::Object>());
-                resolve_target = res->GetTextureView();
-            }
-
-            // 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;
-                }
-            }
-
-
-            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;
-                }
+                auto res = GPUTextureViewImpl::GetPointer(resolveTargetVal.As<v8::Object>());
+                resolveTarget = res->GetTextureView();
             }
-
+            
+            v8::Local<v8::Value> loadVal;
+            v8::Local<v8::Value> storeVal;
+            colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                            "loadOp")).ToLocal(&loadVal);
+            
+            colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                            "storeOp")).ToLocal(&storeVal);
+            
+            
+            CanvasLoadOp load = ParseCanvasLoadOp(isolate, loadVal);
+            CanvasStoreOp store = ParseCanvasStoreOp(isolate, storeVal);
+        
+
+            
             CanvasPassChannelColor channel{
-                    load,
-                    store,
-                    clearValue,
-                    false
+                load,
+                store,
+                clearValue,
+                false
             };
-
+            
             auto attachment = CanvasRenderPassColorAttachment{
-                    view->GetTextureView(),
-                    resolve_target,
-                    channel
+                view,
+                resolveTarget,
+                channel
             };
-
+            
             colorAttachments_.push_back(attachment);
-
+            
         }
-
-
+        
+        
+        // todo add when supported
         v8::Local<v8::Value> maxDrawCountVal;
-
         desc->Get(context, ConvertToV8String(isolate, "maxDrawCount")).ToLocal(&maxDrawCountVal);
-
-
+        
+        
         CanvasRenderPassDepthStencilAttachment *depthStencilAttachment = nullptr;
         v8::Local<v8::Value> depthStencilAttachmentVal;
-
+        
         desc->Get(context, ConvertToV8String(isolate, "depthStencilAttachment")).ToLocal(
-                &depthStencilAttachmentVal);
-
-
+                                                                                         &depthStencilAttachmentVal);
+        
+        
         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;
-
-
+        
+        
         desc->Get(context, ConvertToV8String(isolate, "occlusionQuerySet")).ToLocal(
-                &occlusionQuerySetVal);
-
-
-        if (!occlusionQuerySetVal.IsEmpty() && occlusionQuerySetVal->IsObject()) {
+                                                                                    &occlusionQuerySetVal);
+        
+        
+        if (GetNativeType(occlusionQuerySetVal) == NativeType::GPUQuerySet) {
             auto occlusionQuerySet = GPUQuerySetImpl::GetPointer(
-                    occlusionQuerySetVal.As<v8::Object>());
+                                                                 occlusionQuerySetVal.As<v8::Object>());
             occlusion_query_set = occlusionQuerySet->GetQuerySet();
         }
-
-
+        
+        
         v8::Local<v8::Value> timestampWritesVal;
         desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
-                &timestampWritesVal);
-
-
+                                                                                  &timestampWritesVal);
+        
+        
         const CanvasGPUQuerySet *querySet = nullptr;
         int32_t beginningOfPassWriteIndex = -1;
         int32_t endOfPassWriteIndex = -1;
-
+        
         if (!timestampWritesVal.IsEmpty() && timestampWritesVal->IsObject()) {
             auto timestampWrites = timestampWritesVal.As<v8::Object>();
             v8::Local<v8::Value> querySetVal;
             timestampWrites->Get(context, ConvertToV8String(isolate, "querySet")).ToLocal(
-                    &querySetVal);
-
-
-            if (!querySetVal.IsEmpty() && querySetVal->IsObject()) {
+                                                                                          &querySetVal);
+            
+            
+            if (GetNativeType(querySetVal) == NativeType::GPUQuerySet) {
                 auto queryPtr = GPUQuerySetImpl::GetPointer(querySetVal.As<v8::Object>());
                 if (queryPtr != nullptr) {
                     querySet = queryPtr->GetQuerySet();
                 }
             }
-
+            
             v8::Local<v8::Value> beginningOfPassWriteIndexVal;
-
+            
             v8::Local<v8::Value> endOfPassWriteIndexVal;
-
-
+            
+            
             auto beginningOfPassWriteIndexValSuccess = timestampWrites->Get(context,
                                                                             ConvertToV8String(
-                                                                                    isolate,
-                                                                                    "beginningOfPassWriteIndex")).ToLocal(
-                    &beginningOfPassWriteIndexVal);
-
+                                                                                              isolate,
+                                                                                              "beginningOfPassWriteIndex")).ToLocal(
+                                                                                                                                    &beginningOfPassWriteIndexVal);
+            
             auto endOfPassWriteIndexValSuccess = timestampWrites->Get(context,
                                                                       ConvertToV8String(isolate,
                                                                                         "endOfPassWriteIndex")).ToLocal(
-                    &endOfPassWriteIndexVal);
-
-
+                                                                                                                        &endOfPassWriteIndexVal);
+            
+            
             if (beginningOfPassWriteIndexValSuccess && beginningOfPassWriteIndexVal->IsInt32()) {
                 beginningOfPassWriteIndex = beginningOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
-
+            
             if (endOfPassWriteIndexValSuccess && endOfPassWriteIndexVal->IsInt32()) {
                 endOfPassWriteIndex = endOfPassWriteIndexVal.As<v8::Int32>()->Value();
             }
-
+            
         }
-
-
+        
+        
         pass = canvas_native_webgpu_command_encoder_begin_render_pass(
-                ptr->GetEncoder(), label, colorAttachments_.data(), colorAttachments_.size(),
-                depthStencilAttachment, occlusion_query_set,
-                querySet, beginningOfPassWriteIndex, endOfPassWriteIndex
-        );
-
-
+                                                                      ptr->GetEncoder(), label.c_str(), colorAttachments_.data(), colorAttachments_.size(),
+                                                                      depthStencilAttachment, occlusion_query_set,
+                                                                      querySet, beginningOfPassWriteIndex, endOfPassWriteIndex
+                                                                      );
+        
+        if (depthStencilAttachment != nullptr) {
+            delete depthStencilAttachment;
+            depthStencilAttachment = nullptr;
+        }
+        
+        
     }
-
-
+    
+    
     if (pass != nullptr) {
         auto value = new GPURenderPassEncoderImpl(pass);
         auto ret = GPURenderPassEncoderImpl::NewInstance(isolate, value);
@@ -462,7 +597,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
     } else {
         args.GetReturnValue().SetUndefined();
     }
-
+    
 }
 
 void GPUCommandEncoderImpl::ClearBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -470,37 +605,37 @@ void GPUCommandEncoderImpl::ClearBuffer(const v8::FunctionCallbackInfo<v8::Value
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto bufferVal = args[0];
     const CanvasGPUBuffer *buffer = nullptr;
-
+    
     if (bufferVal->IsObject()) {
         auto bufferPtr = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
         if (bufferPtr != nullptr) {
             buffer = bufferPtr->GetGPUBuffer();
         }
     }
-
+    
     if (buffer == nullptr) {
         return;
     }
-
+    
     int64_t offset = -1;
     auto offsetVal = args[1];
-
+    
     if (offsetVal->IsNumber()) {
         offset = (int64_t) offsetVal.As<v8::Number>()->Value();
     }
-
+    
     int64_t size = -1;
     auto sizeVal = args[2];
-
+    
     if (sizeVal->IsNumber()) {
         size = (int64_t) sizeVal.As<v8::Number>()->Value();
     }
-
+    
     canvas_native_webgpu_command_encoder_clear_buffer(ptr->GetEncoder(), buffer, offset, size);
-
+    
 }
 
 void GPUCommandEncoderImpl::CopyBufferToBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -510,7 +645,7 @@ void GPUCommandEncoderImpl::CopyBufferToBuffer(const v8::FunctionCallbackInfo<v8
     }
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
+    
     auto source = args[0];
     auto sourceType = GetNativeType(source);
     auto sourceOffset = args[1];
@@ -518,22 +653,22 @@ void GPUCommandEncoderImpl::CopyBufferToBuffer(const v8::FunctionCallbackInfo<v8
     auto destinationType = GetNativeType(destination);
     auto destinationOffset = args[3];
     auto size = args[4];
-
+    
     if (sourceType == NativeType::GPUBuffer && destinationType == NativeType::GPUBuffer) {
         auto src = GPUBufferImpl::GetPointer(source.As<v8::Object>());
         auto dst = GPUBufferImpl::GetPointer(destination.As<v8::Object>());
         canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(ptr->GetEncoder(),
                                                                    src->GetGPUBuffer(),
                                                                    (int64_t) sourceOffset->NumberValue(
-                                                                           context).FromJust(),
+                                                                                                       context).FromJust(),
                                                                    dst->GetGPUBuffer(),
                                                                    (int64_t) destinationOffset->NumberValue(
-                                                                           context).FromJust(),
+                                                                                                            context).FromJust(),
                                                                    (uint64_t) size->NumberValue(
-                                                                           context).FromJust()
-        );
+                                                                                                context).FromJust()
+                                                                   );
     }
-
+    
 }
 
 void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -541,15 +676,15 @@ void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v
     if (ptr == nullptr) {
         return;
     }
-
-
+    
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
+    
     auto source = args[0];
     auto destination = args[1];
     auto copySize = args[2];
-
+    
     if (source->IsObject() && destination->IsObject() && copySize->IsObject()) {
         const CanvasGPUBuffer *buffer = nullptr;
         auto src = source.As<v8::Object>();
@@ -560,73 +695,73 @@ void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v
         }
         uint64_t offset = 0;
         int32_t rowsPerImage = -1;
-
+        
         v8::Local<v8::Value> rowsPerImageVal;
-
+        
         src->Get(context, ConvertToV8String(isolate, "rowsPerImage")).ToLocal(&rowsPerImageVal);
-
+        
         if (!rowsPerImageVal.IsEmpty() && rowsPerImageVal->IsInt32()) {
             rowsPerImage = rowsPerImageVal->Int32Value(context).FromJust();
         }
-
-
+        
+        
         v8::Local<v8::Value> offsetVal;
-
+        
         src->Get(context, ConvertToV8String(isolate, "offset")).ToLocal(&offsetVal);
-
+        
         if (!offsetVal.IsEmpty() && offsetVal->IsNumber()) {
             offset = (int64_t) offsetVal->NumberValue(context).FromJust();
         }
-
+        
         v8::Local<v8::Value> bytesPerRowVal;
-
+        
         src->Get(context, ConvertToV8String(isolate, "bytesPerRow")).ToLocal(&bytesPerRowVal);
-
+        
         CanvasImageCopyBuffer copy{
-                buffer,
-                offset,
-                bytesPerRowVal->Int32Value(context).FromJust(),
-                rowsPerImage
+            buffer,
+            offset,
+            bytesPerRowVal->Int32Value(context).FromJust(),
+            rowsPerImage
         };
-
-
+        
+        
         uint32_t mipLevel = 0;
         CanvasOrigin3d origin{0, 0, 0};
         CanvasTextureAspect aspect = CanvasTextureAspectAll;
-
+        
         const CanvasGPUTexture *texture = nullptr;
         auto dst = destination.As<v8::Object>();
-
-
+        
+        
         v8::Local<v8::Value> textureVal;
         dst->Get(context, ConvertToV8String(isolate, "texture")).ToLocal(&textureVal);
         if (GetNativeType(textureVal) == NativeType::GPUTexture) {
             texture = GPUTextureImpl::GetPointer(textureVal.As<v8::Object>())->GetTexture();
         }
-
-
+        
+        
         v8::Local<v8::Value> mipLevelVal;
         dst->Get(context, ConvertToV8String(isolate, "mipLevel")).ToLocal(&mipLevelVal);
-
+        
         if (!mipLevelVal.IsEmpty() && mipLevelVal->IsUint32()) {
             mipLevel = mipLevelVal->Uint32Value(context).FromJust();
         }
-
+        
         v8::Local<v8::Value> originVal;
         dst->Get(context, ConvertToV8String(isolate, "origin")).ToLocal(&originVal);
-
-
+        
+        
         if (!originVal.IsEmpty() && originVal->IsObject()) {
             auto originObj = originVal.As<v8::Object>();
-
-
+            
+            
             v8::Local<v8::Value> xVal;
             v8::Local<v8::Value> yVal;
             v8::Local<v8::Value> zVal;
             originObj->Get(context, ConvertToV8String(isolate, "x")).ToLocal(&xVal);
             originObj->Get(context, ConvertToV8String(isolate, "y")).ToLocal(&yVal);
             originObj->Get(context, ConvertToV8String(isolate, "z")).ToLocal(&zVal);
-
+            
             if (xVal->IsUint32()) {
                 origin.x = xVal->Uint32Value(context).FromJust();
             }
@@ -636,36 +771,36 @@ void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v
             if (zVal->IsUint32()) {
                 origin.z = zVal->Uint32Value(context).FromJust();
             }
-
+            
         }
-
-
+        
+        
         v8::Local<v8::Value> aspectVal;
         dst->Get(context, ConvertToV8String(isolate, "aspect")).ToLocal(&aspectVal);
-
-
+        
+        
         auto aspectStr = ConvertFromV8String(isolate, aspectVal);
-
+        
         if (aspectStr == "stencil-only") {
             aspect = CanvasTextureAspectStencilOnly;
         } else if (aspectStr == "depth-only") {
             aspect = CanvasTextureAspectDepthOnly;
         }
-
+        
         CanvasImageCopyTexture ct{
-                texture, mipLevel, origin, aspect
+            texture, mipLevel, origin, aspect
         };
-
+        
         CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
         canvas_native_webgpu_command_encoder_copy_buffer_to_texture(
-                ptr->GetEncoder(),
-                &copy,
-                &ct,
-                &cz
-        );
+                                                                    ptr->GetEncoder(),
+                                                                    &copy,
+                                                                    &ct,
+                                                                    &cz
+                                                                    );
     }
-
-
+    
+    
 }
 
 void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -673,20 +808,20 @@ void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v
     if (ptr == nullptr) {
         return;
     }
-
-
+    
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
+    
     // copying texture to buffer swapped the real source and dst
     auto source = args[1];
     auto destination = args[0];
     auto copySize = args[2];
-
+    
     if (source->IsObject() && destination->IsObject() && copySize->IsObject()) {
         const CanvasGPUBuffer *buffer = nullptr;
         auto src = source.As<v8::Object>();
-
+        
         v8::Local<v8::Value> bufferVal;
         src->Get(context, ConvertToV8String(isolate, "buffer")).ToLocal(&bufferVal);
         if (GetNativeType(bufferVal) == NativeType::GPUBuffer) {
@@ -694,73 +829,73 @@ void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v
         }
         uint64_t offset = 0;
         int32_t rowsPerImage = -1;
-
+        
         v8::Local<v8::Value> rowsPerImageVal;
-
+        
         src->Get(context, ConvertToV8String(isolate, "rowsPerImage")).ToLocal(&rowsPerImageVal);
-
+        
         if (!rowsPerImageVal.IsEmpty() && rowsPerImageVal->IsInt32()) {
             rowsPerImage = rowsPerImageVal->Int32Value(context).FromJust();
         }
-
-
+        
+        
         v8::Local<v8::Value> offsetVal;
-
+        
         src->Get(context, ConvertToV8String(isolate, "offset")).ToLocal(&offsetVal);
-
+        
         if (!offsetVal.IsEmpty() && offsetVal->IsNumber()) {
             offset = (int64_t) offsetVal->NumberValue(context).FromJust();
         }
-
+        
         v8::Local<v8::Value> bytesPerRowVal;
-
+        
         src->Get(context, ConvertToV8String(isolate, "bytesPerRow")).ToLocal(&bytesPerRowVal);
-
+        
         CanvasImageCopyBuffer copy{
-                buffer,
-                offset,
-                bytesPerRowVal->Int32Value(context).FromJust(),
-                rowsPerImage
+            buffer,
+            offset,
+            bytesPerRowVal->Int32Value(context).FromJust(),
+            rowsPerImage
         };
-
-
+        
+        
         uint32_t mipLevel = 0;
         CanvasOrigin3d origin{0, 0, 0};
         CanvasTextureAspect aspect = CanvasTextureAspectAll;
-
+        
         const CanvasGPUTexture *texture = nullptr;
         auto dst = destination.As<v8::Object>();
-
-
+        
+        
         v8::Local<v8::Value> textureVal;
         dst->Get(context, ConvertToV8String(isolate, "texture")).ToLocal(&textureVal);
         if (GetNativeType(textureVal) == NativeType::GPUTexture) {
             texture = GPUTextureImpl::GetPointer(textureVal.As<v8::Object>())->GetTexture();
         }
-
-
+        
+        
         v8::Local<v8::Value> mipLevelVal;
         dst->Get(context, ConvertToV8String(isolate, "mipLevel")).ToLocal(&mipLevelVal);
-
+        
         if (!mipLevelVal.IsEmpty() && mipLevelVal->IsUint32()) {
             mipLevel = mipLevelVal->Uint32Value(context).FromJust();
         }
-
+        
         v8::Local<v8::Value> originVal;
         dst->Get(context, ConvertToV8String(isolate, "origin")).ToLocal(&originVal);
-
-
+        
+        
         if (!originVal.IsEmpty() && originVal->IsObject()) {
             auto originObj = originVal.As<v8::Object>();
-
-
+            
+            
             v8::Local<v8::Value> xVal;
             v8::Local<v8::Value> yVal;
             v8::Local<v8::Value> zVal;
             originObj->Get(context, ConvertToV8String(isolate, "x")).ToLocal(&xVal);
             originObj->Get(context, ConvertToV8String(isolate, "y")).ToLocal(&yVal);
             originObj->Get(context, ConvertToV8String(isolate, "z")).ToLocal(&zVal);
-
+            
             if (xVal->IsUint32()) {
                 origin.x = xVal->Uint32Value(context).FromJust();
             }
@@ -770,36 +905,36 @@ void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v
             if (zVal->IsUint32()) {
                 origin.z = zVal->Uint32Value(context).FromJust();
             }
-
+            
         }
-
-
+        
+        
         v8::Local<v8::Value> aspectVal;
         dst->Get(context, ConvertToV8String(isolate, "aspect")).ToLocal(&aspectVal);
-
-
+        
+        
         auto aspectStr = ConvertFromV8String(isolate, aspectVal);
-
+        
         if (aspectStr == "stencil-only") {
             aspect = CanvasTextureAspectStencilOnly;
         } else if (aspectStr == "depth-only") {
             aspect = CanvasTextureAspectDepthOnly;
         }
-
+        
         CanvasImageCopyTexture ct{
-                texture, mipLevel, origin, aspect
+            texture, mipLevel, origin, aspect
         };
-
+        
         CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
         canvas_native_webgpu_command_encoder_copy_texture_to_buffer(
-                ptr->GetEncoder(),
-                &ct,
-                &copy,
-                &cz
-        );
+                                                                    ptr->GetEncoder(),
+                                                                    &ct,
+                                                                    &copy,
+                                                                    &cz
+                                                                    );
     }
-
-
+    
+    
 }
 
 void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -807,51 +942,51 @@ void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
+    
     // copying texture to buffer swapped the real source and dst
     auto source = args[0];
     auto destination = args[1];
     auto copySize = args[2];
-
+    
     if (source->IsObject() && destination->IsObject() && copySize->IsObject()) {
         auto src = source.As<v8::Object>();
-
+        
         uint32_t mipLevelA = 0;
         CanvasOrigin3d originA{0, 0, 0};
         CanvasTextureAspect aspectA = CanvasTextureAspectAll;
-
+        
         const CanvasGPUTexture *textureA = nullptr;
-
+        
         v8::Local<v8::Value> srcTextureVal;
         src->Get(context, ConvertToV8String(isolate, "texture")).ToLocal(&srcTextureVal);
         if (GetNativeType(srcTextureVal) == NativeType::GPUTexture) {
             textureA = GPUTextureImpl::GetPointer(srcTextureVal.As<v8::Object>())->GetTexture();
         }
-
+        
         v8::Local<v8::Value> mipLevelAVal;
         src->Get(context, ConvertToV8String(isolate, "mipLevel")).ToLocal(&mipLevelAVal);
-
+        
         if (!mipLevelAVal.IsEmpty() && mipLevelAVal->IsUint32()) {
             mipLevelA = mipLevelAVal->Uint32Value(context).FromJust();
         }
-
+        
         v8::Local<v8::Value> originAVal;
         src->Get(context, ConvertToV8String(isolate, "origin")).ToLocal(&originAVal);
-
-
+        
+        
         if (!originAVal.IsEmpty() && originAVal->IsObject()) {
             auto originObj = originAVal.As<v8::Object>();
-
+            
             v8::Local<v8::Value> xVal;
             v8::Local<v8::Value> yVal;
             v8::Local<v8::Value> zVal;
             originObj->Get(context, ConvertToV8String(isolate, "x")).ToLocal(&xVal);
             originObj->Get(context, ConvertToV8String(isolate, "y")).ToLocal(&yVal);
             originObj->Get(context, ConvertToV8String(isolate, "z")).ToLocal(&zVal);
-
+            
             if (xVal->IsUint32()) {
                 originA.x = xVal->Uint32Value(context).FromJust();
             }
@@ -861,58 +996,58 @@ void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<
             if (zVal->IsUint32()) {
                 originA.z = zVal->Uint32Value(context).FromJust();
             }
-
+            
         }
-
+        
         v8::Local<v8::Value> aspectAVal;
         src->Get(context, ConvertToV8String(isolate, "aspect")).ToLocal(&aspectAVal);
-
+        
         auto aspectAStr = ConvertFromV8String(isolate, aspectAVal);
-
+        
         if (aspectAStr == "stencil-only") {
             aspectA = CanvasTextureAspectStencilOnly;
         } else if (aspectAStr == "depth-only") {
             aspectA = CanvasTextureAspectDepthOnly;
         }
         CanvasImageCopyTexture copy{
-                textureA, mipLevelA, originA, aspectA
+            textureA, mipLevelA, originA, aspectA
         };
-
+        
         uint32_t mipLevel = 0;
         CanvasOrigin3d origin{0, 0, 0};
         CanvasTextureAspect aspect = CanvasTextureAspectAll;
-
+        
         const CanvasGPUTexture *texture = nullptr;
         auto dst = destination.As<v8::Object>();
-
-
+        
+        
         v8::Local<v8::Value> textureVal;
         dst->Get(context, ConvertToV8String(isolate, "texture")).ToLocal(&textureVal);
         if (GetNativeType(textureVal) == NativeType::GPUTexture) {
             texture = GPUTextureImpl::GetPointer(textureVal.As<v8::Object>())->GetTexture();
         }
-
-
+        
+        
         v8::Local<v8::Value> mipLevelVal;
         dst->Get(context, ConvertToV8String(isolate, "mipLevel")).ToLocal(&mipLevelVal);
-
+        
         if (!mipLevelVal.IsEmpty() && mipLevelVal->IsUint32()) {
             mipLevel = mipLevelVal->Uint32Value(context).FromJust();
         }
-
+        
         v8::Local<v8::Value> originVal;
         dst->Get(context, ConvertToV8String(isolate, "origin")).ToLocal(&originVal);
-
+        
         if (!originVal.IsEmpty() && originVal->IsObject()) {
             auto originObj = originVal.As<v8::Object>();
-
+            
             v8::Local<v8::Value> xVal;
             v8::Local<v8::Value> yVal;
             v8::Local<v8::Value> zVal;
             originObj->Get(context, ConvertToV8String(isolate, "x")).ToLocal(&xVal);
             originObj->Get(context, ConvertToV8String(isolate, "y")).ToLocal(&yVal);
             originObj->Get(context, ConvertToV8String(isolate, "z")).ToLocal(&zVal);
-
+            
             if (xVal->IsUint32()) {
                 origin.x = xVal->Uint32Value(context).FromJust();
             }
@@ -922,36 +1057,36 @@ void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<
             if (zVal->IsUint32()) {
                 origin.z = zVal->Uint32Value(context).FromJust();
             }
-
+            
         }
-
-
+        
+        
         v8::Local<v8::Value> aspectVal;
         dst->Get(context, ConvertToV8String(isolate, "aspect")).ToLocal(&aspectVal);
-
+        
         auto aspectStr = ConvertFromV8String(isolate, aspectVal);
-
+        
         if (aspectStr == "stencil-only") {
             aspect = CanvasTextureAspectStencilOnly;
         } else if (aspectStr == "depth-only") {
             aspect = CanvasTextureAspectDepthOnly;
         }
-
+        
         CanvasImageCopyTexture ct{
-                texture, mipLevel, origin, aspect
+            texture, mipLevel, origin, aspect
         };
-
+        
         CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
-
+        
         canvas_native_webgpu_command_encoder_copy_texture_to_texture(
-                ptr->GetEncoder(),
-                &copy,
-                &ct,
-                &cz
-        );
+                                                                     ptr->GetEncoder(),
+                                                                     &copy,
+                                                                     &ct,
+                                                                     &cz
+                                                                     );
     }
-
-
+    
+    
 }
 
 void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -959,33 +1094,31 @@ void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &ar
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
-
+    
     auto descVal = args[0];
     std::string label;
     bool didSet = false;
     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;
         }
     }
-
+    
     auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(),
                                                              didSet ? label.c_str() : nullptr);
-
+    
     if (value != nullptr) {
         auto ret = GPUCommandBufferImpl::NewInstance(isolate, new GPUCommandBufferImpl(value));
         args.GetReturnValue().Set(ret);
         return;
     }
-
+    
     args.GetReturnValue().SetUndefined();
 }
 
@@ -995,9 +1128,9 @@ GPUCommandEncoderImpl::InsertDebugMarker(const v8::FunctionCallbackInfo<v8::Valu
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
-
+    
     auto markerLabelVal = args[0];
     if (markerLabelVal->IsString()) {
         auto markerLabel = ConvertFromV8String(isolate, markerLabelVal);
@@ -1011,7 +1144,7 @@ void GPUCommandEncoderImpl::PopDebugGroup(const v8::FunctionCallbackInfo<v8::Val
     if (ptr == nullptr) {
         return;
     }
-
+    
     canvas_native_webgpu_command_encoder_pop_debug_group(ptr->GetEncoder());
 }
 
@@ -1020,9 +1153,9 @@ void GPUCommandEncoderImpl::PushDebugGroup(const v8::FunctionCallbackInfo<v8::Va
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
-
+    
     auto groupLabelVal = args[0];
     if (groupLabelVal->IsString()) {
         auto groupLabel = ConvertFromV8String(isolate, groupLabelVal);
@@ -1036,10 +1169,10 @@ void GPUCommandEncoderImpl::ResolveQuerySet(const v8::FunctionCallbackInfo<v8::V
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
+    
     auto querySet = args[0];
     auto queryType = GetNativeType(querySet);
     auto firstQuery = args[1];
@@ -1047,19 +1180,19 @@ void GPUCommandEncoderImpl::ResolveQuerySet(const v8::FunctionCallbackInfo<v8::V
     auto destination = args[3];
     auto destinationType = GetNativeType(destination);
     auto destinationOffset = args[4];
-
-
+    
+    
     if (queryType == NativeType::GPUQuerySet && destinationType == NativeType::GPUBuffer) {
         auto qs = GPUQuerySetImpl::GetPointer(querySet.As<v8::Object>());
         auto dest = GPUBufferImpl::GetPointer(destination.As<v8::Object>());
         canvas_native_webgpu_command_encoder_resolve_query_set(ptr->GetEncoder(), qs->GetQuerySet(),
                                                                firstQuery->Uint32Value(
-                                                                       context).FromJust(),
+                                                                                       context).FromJust(),
                                                                queryCount->Uint32Value(
-                                                                       context).FromJust(),
+                                                                                       context).FromJust(),
                                                                dest->GetGPUBuffer(),
                                                                (uint64_t) destinationOffset->NumberValue(
-                                                                       context).FromJust());
+                                                                                                         context).FromJust());
     }
 }
 
@@ -1068,20 +1201,20 @@ void GPUCommandEncoderImpl::WriteTimestamp(const v8::FunctionCallbackInfo<v8::Va
     if (ptr == nullptr) {
         return;
     }
-
+    
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-
+    
     auto querySet = args[0];
     auto queryType = GetNativeType(querySet);
     auto queryIndex = args[1];
-
+    
     if (queryType == NativeType::GPUQuerySet) {
         auto qs = GPUQuerySetImpl::GetPointer(querySet.As<v8::Object>());
         canvas_native_webgpu_command_encoder_write_timestamp(ptr->GetEncoder(), qs->GetQuerySet(),
                                                              queryIndex->Uint32Value(
-                                                                     context).FromJust());
+                                                                                     context).FromJust());
     }
-
-
+    
+    
 }