@nativescript/canvas 2.0.0-rc.2 → 2.0.0-rc.20

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

@@ -14,1204 +14,1210 @@
 #include "GPULabel.h"
 
 GPUCommandEncoderImpl::GPUCommandEncoderImpl(const CanvasGPUCommandEncoder *encoder) : encoder_(
-        encoder) {}
+																																																encoder) {}
 
 const CanvasGPUCommandEncoder *GPUCommandEncoderImpl::GetEncoder() {
-    return this->encoder_;
+	return this->encoder_;
 }
 
 void GPUCommandEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *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();
+	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();
 }
 
 GPUCommandEncoderImpl *GPUCommandEncoderImpl::GetPointer(const v8::Local<v8::Object> &object) {
-    auto ptr = object->GetAlignedPointerFromInternalField(0);
-    if (ptr == nullptr) {
-        return nullptr;
-    }
-    return static_cast<GPUCommandEncoderImpl *>(ptr);
+	auto ptr = object->GetAlignedPointerFromInternalField(0);
+	if (ptr == nullptr) {
+		return nullptr;
+	}
+	return static_cast<GPUCommandEncoderImpl *>(ptr);
 }
 
 v8::Local<v8::FunctionTemplate> GPUCommandEncoderImpl::GetCtor(v8::Isolate *isolate) {
-    auto cache = Caches::Get(isolate);
-    auto ctor = cache->GPUCommandEncoderTmpl.get();
-    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));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "beginRenderPass"),
-            v8::FunctionTemplate::New(isolate, &BeginRenderPass));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "clearBuffer"),
-            v8::FunctionTemplate::New(isolate, &ClearBuffer));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "copyBufferToBuffer"),
-            v8::FunctionTemplate::New(isolate, &CopyBufferToBuffer));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "copyBufferToTexture"),
-            v8::FunctionTemplate::New(isolate, &CopyBufferToTexture));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "copyTextureToBuffer"),
-            v8::FunctionTemplate::New(isolate, &CopyTextureToBuffer));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "copyTextureToTexture"),
-            v8::FunctionTemplate::New(isolate, &CopyTextureToTexture));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "finish"),
-            v8::FunctionTemplate::New(isolate, &Finish));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "insertDebugMarker"),
-            v8::FunctionTemplate::New(isolate, &InsertDebugMarker));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "popDebugGroup"),
-            v8::FunctionTemplate::New(isolate, &PopDebugGroup));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "pushDebugGroup"),
-            v8::FunctionTemplate::New(isolate, &PushDebugGroup));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "resolveQuerySet"),
-            v8::FunctionTemplate::New(isolate, &ResolveQuerySet));
-
-    tmpl->Set(
-            ConvertToV8String(isolate, "writeTimestamp"),
-            v8::FunctionTemplate::New(isolate, &WriteTimestamp));
-
-
-    cache->GPUCommandEncoderTmpl =
-            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
-    return ctorTmpl;
+	auto cache = Caches::Get(isolate);
+	auto ctor = cache->GPUCommandEncoderTmpl.get();
+	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));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "beginRenderPass"),
+						v8::FunctionTemplate::New(isolate, &BeginRenderPass));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "clearBuffer"),
+						v8::FunctionTemplate::New(isolate, &ClearBuffer));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "copyBufferToBuffer"),
+						v8::FunctionTemplate::New(isolate, &CopyBufferToBuffer));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "copyBufferToTexture"),
+						v8::FunctionTemplate::New(isolate, &CopyBufferToTexture));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "copyTextureToBuffer"),
+						v8::FunctionTemplate::New(isolate, &CopyTextureToBuffer));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "copyTextureToTexture"),
+						v8::FunctionTemplate::New(isolate, &CopyTextureToTexture));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "finish"),
+						v8::FunctionTemplate::New(isolate, &Finish));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "insertDebugMarker"),
+						v8::FunctionTemplate::New(isolate, &InsertDebugMarker));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "popDebugGroup"),
+						v8::FunctionTemplate::New(isolate, &PopDebugGroup));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "pushDebugGroup"),
+						v8::FunctionTemplate::New(isolate, &PushDebugGroup));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "resolveQuerySet"),
+						v8::FunctionTemplate::New(isolate, &ResolveQuerySet));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "writeTimestamp"),
+						v8::FunctionTemplate::New(isolate, &WriteTimestamp));
+	
+	
+	cache->GPUCommandEncoderTmpl =
+	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();
+																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);
-
-        auto label = GPULabel(isolate, labelVal);
-
-        const CanvasGPUQuerySet *querySet = nullptr;
-
-        int32_t beginningOfPassWriteIndex = -1;
-
-        int32_t endOfPassWriteIndex = -1;
-
-
-        v8::Local<v8::Value> timestampWritesVal;
-
-        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;
-            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;
-
-
-            success = timestampWrites->Get(context,
-                                           ConvertToV8String(isolate,
-                                                             "beginningOfPassWriteIndex")).ToLocal(
-                    &beginningOfPassWriteIndexVal);
-
-            if (success && beginningOfPassWriteIndexVal->IsInt32()) {
-                beginningOfPassWriteIndex = beginningOfPassWriteIndexVal.As<v8::Int32>()->Value();
-            }
-
-            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,
-                                                                       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);
-        args.GetReturnValue().Set(ret);
-    } else {
-        args.GetReturnValue().SetUndefined();
-    }
-
+	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);
+		
+		auto label = GPULabel(isolate, labelVal);
+		
+		const CanvasGPUQuerySet *querySet = nullptr;
+		
+		int32_t beginningOfPassWriteIndex = -1;
+		
+		int32_t endOfPassWriteIndex = -1;
+		
+		
+		v8::Local<v8::Value> timestampWritesVal;
+		
+		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;
+			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;
+			
+			
+			success = timestampWrites->Get(context,
+																		 ConvertToV8String(isolate,
+																											 "beginningOfPassWriteIndex")).ToLocal(
+																																														 &beginningOfPassWriteIndexVal);
+			
+			if (success && beginningOfPassWriteIndexVal->IsInt32()) {
+				beginningOfPassWriteIndex = beginningOfPassWriteIndexVal.As<v8::Int32>()->Value();
+			}
+			
+			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,
+																																	 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);
+		args.GetReturnValue().Set(ret);
+	} else {
+		args.GetReturnValue().SetUndefined();
+	}
+	
 }
 
 void GPUCommandEncoderImpl::BeginRenderPass(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 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);
-
-        auto label = GPULabel(isolate, labelVal);
-
-
-        v8::Local<v8::Value> colorAttachmentsVal;
-        desc->Get(context, ConvertToV8String(isolate, "colorAttachments")).ToLocal(
-                &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 = 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();
-                }
-            }
-
-
-            const CanvasGPUTextureView *resolveTarget = nullptr;
-
-            v8::Local<v8::Value> resolveTargetVal;
-
-            colorAttachment->Get(context, ConvertToV8String(isolate, "resolveTarget")).ToLocal(
-                    &resolveTargetVal);
-
-            auto resolve_target_type = GetNativeType(resolveTargetVal);
-
-            if (resolve_target_type == NativeType::GPUTextureView) {
-                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
-            };
-
-            auto attachment = CanvasRenderPassColorAttachment{
-                    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);
-
-
-        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 (GetNativeType(occlusionQuerySetVal) == NativeType::GPUQuerySet) {
-            auto occlusionQuerySet = GPUQuerySetImpl::GetPointer(
-                    occlusionQuerySetVal.As<v8::Object>());
-            occlusion_query_set = occlusionQuerySet->GetQuerySet();
-        }
-
-
-        v8::Local<v8::Value> timestampWritesVal;
-        desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
-                &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 (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);
-
-            auto endOfPassWriteIndexValSuccess = timestampWrites->Get(context,
-                                                                      ConvertToV8String(isolate,
-                                                                                        "endOfPassWriteIndex")).ToLocal(
-                    &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
-        );
-
-        if (depthStencilAttachment != nullptr) {
-            delete depthStencilAttachment;
-            depthStencilAttachment = nullptr;
-        }
-
-
-    }
-
-
-    if (pass != nullptr) {
-        auto value = new GPURenderPassEncoderImpl(pass);
-        auto ret = GPURenderPassEncoderImpl::NewInstance(isolate, value);
-        args.GetReturnValue().Set(ret);
-    } else {
-        args.GetReturnValue().SetUndefined();
-    }
-
+	auto ptr = GetPointer(args.This());
+	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);
+		
+		auto label = GPULabel(isolate, labelVal);
+		
+		
+		v8::Local<v8::Value> colorAttachmentsVal;
+		desc->Get(context, ConvertToV8String(isolate, "colorAttachments")).ToLocal(
+																																							 &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 = 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();
+				}
+			}
+			
+			
+			const CanvasGPUTextureView *resolveTarget = nullptr;
+			
+			v8::Local<v8::Value> resolveTargetVal;
+			
+			colorAttachment->Get(context, ConvertToV8String(isolate, "resolveTarget")).ToLocal(
+																																												 &resolveTargetVal);
+			
+			auto resolve_target_type = GetNativeType(resolveTargetVal);
+			
+			if (resolve_target_type == NativeType::GPUTextureView) {
+				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
+			};
+			
+			auto attachment = CanvasRenderPassColorAttachment{
+				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);
+		
+		
+		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 = CanvasOptionF32{
+				CanvasOptionF32None
+			};
+			
+			if (!depthClearValue.IsEmpty() && depthClearValue->IsNumber()) {
+				depthStencilAttachment->depth_clear_value.tag = CanvasOptionF32Some;
+				depthStencilAttachment->depth_clear_value.some = (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 (GetNativeType(occlusionQuerySetVal) == NativeType::GPUQuerySet) {
+			auto occlusionQuerySet = GPUQuerySetImpl::GetPointer(
+																													 occlusionQuerySetVal.As<v8::Object>());
+			occlusion_query_set = occlusionQuerySet->GetQuerySet();
+		}
+		
+		
+		v8::Local<v8::Value> timestampWritesVal;
+		desc->Get(context, ConvertToV8String(isolate, "timestampWrites")).ToLocal(
+																																							&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 (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);
+			
+			auto endOfPassWriteIndexValSuccess = timestampWrites->Get(context,
+																																ConvertToV8String(isolate,
+																																									"endOfPassWriteIndex")).ToLocal(
+																																																									&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
+																																	);
+		
+		if (depthStencilAttachment != nullptr) {
+			delete depthStencilAttachment;
+			depthStencilAttachment = nullptr;
+		}
+		
+		
+	}
+	
+	
+	if (pass != nullptr) {
+		auto value = new GPURenderPassEncoderImpl(pass);
+		auto ret = GPURenderPassEncoderImpl::NewInstance(isolate, value);
+		args.GetReturnValue().Set(ret);
+	} else {
+		args.GetReturnValue().SetUndefined();
+	}
+	
 }
 
 void GPUCommandEncoderImpl::ClearBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto ptr = GetPointer(args.This());
-    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);
-
+	auto ptr = GetPointer(args.This());
+	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) {
-    auto ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
-
-    auto source = args[0];
-    auto sourceType = GetNativeType(source);
-    auto sourceOffset = args[1];
-    auto destination = args[2];
-    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(),
-                                                                   dst->GetGPUBuffer(),
-                                                                   (int64_t) destinationOffset->NumberValue(
-                                                                           context).FromJust(),
-                                                                   (uint64_t) size->NumberValue(
-                                                                           context).FromJust()
-        );
-    }
-
+	auto ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	auto isolate = args.GetIsolate();
+	auto context = isolate->GetCurrentContext();
+	
+	auto source = args[0];
+	auto sourceType = GetNativeType(source);
+	auto sourceOffset = args[1];
+	auto destination = args[2];
+	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>());
+		int64_t sizeValue = -1;
+		if(size->IsNumber()){
+			sizeValue = (int64_t) size->NumberValue(context).FromJust();
+		}
+		canvas_native_webgpu_command_encoder_copy_buffer_to_buffer(ptr->GetEncoder(),
+																															 src->GetGPUBuffer(),
+																															 (int64_t) sourceOffset->NumberValue(
+																																																	 context).FromJust(),
+																															 dst->GetGPUBuffer(),
+																															 (int64_t) destinationOffset->NumberValue(
+																																																				context).FromJust(),
+																															 sizeValue
+																															 );
+	}
+	
 }
 
 void GPUCommandEncoderImpl::CopyBufferToTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto ptr = GetPointer(args.This());
-    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>();
-        v8::Local<v8::Value> bufferVal;
-        src->Get(context, ConvertToV8String(isolate, "buffer")).ToLocal(&bufferVal);
-        if (GetNativeType(bufferVal) == NativeType::GPUBuffer) {
-            buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>())->GetGPUBuffer();
-        }
-        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
-        };
-
-
-        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();
-            }
-            if (yVal->IsUint32()) {
-                origin.y = yVal->Uint32Value(context).FromJust();
-            }
-            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
-        };
-
-        CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
-        canvas_native_webgpu_command_encoder_copy_buffer_to_texture(
-                ptr->GetEncoder(),
-                &copy,
-                &ct,
-                &cz
-        );
-    }
-
-
+	auto ptr = GetPointer(args.This());
+	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>();
+		v8::Local<v8::Value> bufferVal;
+		src->Get(context, ConvertToV8String(isolate, "buffer")).ToLocal(&bufferVal);
+		if (GetNativeType(bufferVal) == NativeType::GPUBuffer) {
+			buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>())->GetGPUBuffer();
+		}
+		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
+		};
+		
+		
+		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();
+			}
+			if (yVal->IsUint32()) {
+				origin.y = yVal->Uint32Value(context).FromJust();
+			}
+			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
+		};
+		
+		CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
+		canvas_native_webgpu_command_encoder_copy_buffer_to_texture(
+																																ptr->GetEncoder(),
+																																&copy,
+																																&ct,
+																																&cz
+																																);
+	}
+	
+	
 }
 
 void GPUCommandEncoderImpl::CopyTextureToBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto ptr = GetPointer(args.This());
-    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) {
-            buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>())->GetGPUBuffer();
-        }
-        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
-        };
-
-
-        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();
-            }
-            if (yVal->IsUint32()) {
-                origin.y = yVal->Uint32Value(context).FromJust();
-            }
-            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
-        };
-
-        CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
-        canvas_native_webgpu_command_encoder_copy_texture_to_buffer(
-                ptr->GetEncoder(),
-                &ct,
-                &copy,
-                &cz
-        );
-    }
-
-
+	auto ptr = GetPointer(args.This());
+	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) {
+			buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>())->GetGPUBuffer();
+		}
+		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
+		};
+		
+		
+		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();
+			}
+			if (yVal->IsUint32()) {
+				origin.y = yVal->Uint32Value(context).FromJust();
+			}
+			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
+		};
+		
+		CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
+		canvas_native_webgpu_command_encoder_copy_texture_to_buffer(
+																																ptr->GetEncoder(),
+																																&ct,
+																																&copy,
+																																&cz
+																																);
+	}
+	
+	
 }
 
 void GPUCommandEncoderImpl::CopyTextureToTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto ptr = GetPointer(args.This());
-    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();
-            }
-            if (yVal->IsUint32()) {
-                originA.y = yVal->Uint32Value(context).FromJust();
-            }
-            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
-        };
-
-        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();
-            }
-            if (yVal->IsUint32()) {
-                origin.y = yVal->Uint32Value(context).FromJust();
-            }
-            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
-        };
-
-        CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
-
-        canvas_native_webgpu_command_encoder_copy_texture_to_texture(
-                ptr->GetEncoder(),
-                &copy,
-                &ct,
-                &cz
-        );
-    }
-
-
+	auto ptr = GetPointer(args.This());
+	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();
+			}
+			if (yVal->IsUint32()) {
+				originA.y = yVal->Uint32Value(context).FromJust();
+			}
+			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
+		};
+		
+		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();
+			}
+			if (yVal->IsUint32()) {
+				origin.y = yVal->Uint32Value(context).FromJust();
+			}
+			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
+		};
+		
+		CanvasExtent3d cz = ParseExtent3d(isolate, copySize);
+		
+		canvas_native_webgpu_command_encoder_copy_texture_to_texture(
+																																 ptr->GetEncoder(),
+																																 &copy,
+																																 &ct,
+																																 &cz
+																																 );
+	}
+	
+	
 }
 
 void GPUCommandEncoderImpl::Finish(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];
-    GPULabel label;
-    if (descVal->IsObject()) {
-        auto desc = descVal.As<v8::Object>();
-        v8::Local<v8::Value> labelVal;
-        desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
-        label = GPULabel(isolate, labelVal);
-    }
-
-    auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(), *label);
-
-    if (value != nullptr) {
-        auto ret = GPUCommandBufferImpl::NewInstance(isolate, new GPUCommandBufferImpl(value));
-        args.GetReturnValue().Set(ret);
-        return;
-    }
-
-    args.GetReturnValue().SetUndefined();
+	auto ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	auto isolate = args.GetIsolate();
+	auto context = isolate->GetCurrentContext();
+	
+	auto descVal = args[0];
+	GPULabel label;
+	if (descVal->IsObject()) {
+		auto desc = descVal.As<v8::Object>();
+		v8::Local<v8::Value> labelVal;
+		desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
+		label = GPULabel(isolate, labelVal);
+	}
+	
+	auto value = canvas_native_webgpu_command_encoder_finish(ptr->GetEncoder(), *label);
+	
+	if (value != nullptr) {
+		auto ret = GPUCommandBufferImpl::NewInstance(isolate, new GPUCommandBufferImpl(value));
+		args.GetReturnValue().Set(ret);
+		return;
+	}
+	
+	args.GetReturnValue().SetUndefined();
 }
 
 void
 GPUCommandEncoderImpl::InsertDebugMarker(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
-
-    auto isolate = args.GetIsolate();
-
-    auto markerLabelVal = args[0];
-    if (markerLabelVal->IsString()) {
-        auto markerLabel = ConvertFromV8String(isolate, markerLabelVal);
-        canvas_native_webgpu_command_encoder_insert_debug_marker(ptr->GetEncoder(),
-                                                                 markerLabel.c_str());
-    }
+	auto *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	auto isolate = args.GetIsolate();
+	
+	auto markerLabelVal = args[0];
+	if (markerLabelVal->IsString()) {
+		auto markerLabel = ConvertFromV8String(isolate, markerLabelVal);
+		canvas_native_webgpu_command_encoder_insert_debug_marker(ptr->GetEncoder(),
+																														 markerLabel.c_str());
+	}
 }
 
 void GPUCommandEncoderImpl::PopDebugGroup(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
-
-    canvas_native_webgpu_command_encoder_pop_debug_group(ptr->GetEncoder());
+	auto *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	canvas_native_webgpu_command_encoder_pop_debug_group(ptr->GetEncoder());
 }
 
 void GPUCommandEncoderImpl::PushDebugGroup(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
-
-    auto isolate = args.GetIsolate();
-
-    auto groupLabelVal = args[0];
-    if (groupLabelVal->IsString()) {
-        auto groupLabel = ConvertFromV8String(isolate, groupLabelVal);
-        canvas_native_webgpu_command_encoder_push_debug_group(ptr->GetEncoder(),
-                                                              groupLabel.c_str());
-    }
+	auto *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	auto isolate = args.GetIsolate();
+	
+	auto groupLabelVal = args[0];
+	if (groupLabelVal->IsString()) {
+		auto groupLabel = ConvertFromV8String(isolate, groupLabelVal);
+		canvas_native_webgpu_command_encoder_push_debug_group(ptr->GetEncoder(),
+																													groupLabel.c_str());
+	}
 }
 
 void GPUCommandEncoderImpl::ResolveQuerySet(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
-
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
-
-    auto querySet = args[0];
-    auto queryType = GetNativeType(querySet);
-    auto firstQuery = args[1];
-    auto queryCount = args[2];
-    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(),
-                                                               queryCount->Uint32Value(
-                                                                       context).FromJust(),
-                                                               dest->GetGPUBuffer(),
-                                                               (uint64_t) destinationOffset->NumberValue(
-                                                                       context).FromJust());
-    }
+	auto *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	auto isolate = args.GetIsolate();
+	auto context = isolate->GetCurrentContext();
+	
+	auto querySet = args[0];
+	auto queryType = GetNativeType(querySet);
+	auto firstQuery = args[1];
+	auto queryCount = args[2];
+	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(),
+																													 queryCount->Uint32Value(
+																																									 context).FromJust(),
+																													 dest->GetGPUBuffer(),
+																													 (uint64_t) destinationOffset->NumberValue(
+																																																		 context).FromJust());
+	}
 }
 
 void GPUCommandEncoderImpl::WriteTimestamp(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto *ptr = GetPointer(args.This());
-    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());
-    }
-
-
+	auto *ptr = GetPointer(args.This());
+	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());
+	}
+	
+	
 }