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

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

@@ -8,372 +8,477 @@
 #include "GPUUtils.h"
 #include "GPUQueueImpl.h"
 
+v8::CFunction GPUCanvasContextImpl::fast_start_raf_(
+																										v8::CFunction::Make(GPUCanvasContextImpl::__FastStartRaf));
+
+v8::CFunction GPUCanvasContextImpl::fast_stop_raf_(
+																									 v8::CFunction::Make(GPUCanvasContextImpl::__FastStopRaf));
+
+
 GPUCanvasContextImpl::GPUCanvasContextImpl(const CanvasGPUCanvasContext *context) : context_(
-        context) {}
+																																														 context) {
+																																															 auto ctx_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(this));
+																																															 auto raf_callback = new OnRafCallback(ctx_ptr, 3);
+																																															 auto raf_callback_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(raf_callback));
+																																															 auto raf = canvas_native_raf_create(raf_callback_ptr, OnRafCallbackOnFrame);
+																																															 
+																																															 this->SetRaf(std::make_shared<RafImpl>(raf_callback, raf_callback_ptr, raf));
+																																															 
+																																															 auto _raf = this->GetRaf();
+																																															 
+																																															 if (_raf != nullptr) {
+																																																 canvas_native_raf_start(_raf->GetRaf());
+																																															 }
+																																														 }
 
 const CanvasGPUCanvasContext *GPUCanvasContextImpl::GetContext() {
-    return this->context_;
+	return this->context_;
 }
 
 
 void GPUCanvasContextImpl::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, "GPUCanvasContext"), 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, "GPUCanvasContext"), func).FromJust();
 }
 
 GPUCanvasContextImpl *GPUCanvasContextImpl::GetPointer(const v8::Local<v8::Object> &object) {
-    auto ptr = object->GetAlignedPointerFromInternalField(0);
-    if (ptr == nullptr) {
-        return nullptr;
-    }
-    return static_cast<GPUCanvasContextImpl *>(ptr);
+	auto ptr = object->GetAlignedPointerFromInternalField(0);
+	if (ptr == nullptr) {
+		return nullptr;
+	}
+	return static_cast<GPUCanvasContextImpl *>(ptr);
 }
 
-v8::Local<v8::FunctionTemplate> GPUCanvasContextImpl::GetCtor(v8::Isolate *isolate) {
-    auto cache = Caches::Get(isolate);
-    auto ctor = cache->GPUCanvasContextTmpl.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, "GPUCanvasContext"));
-
-    auto tmpl = ctorTmpl->InstanceTemplate();
-    tmpl->SetInternalFieldCount(2);
-
+void GPUCanvasContextImpl::StartRaf() {
+	auto raf = this->GetRaf();
+	if (raf != nullptr) {
+		if (!canvas_native_raf_get_started(raf->GetRaf())) {
+			canvas_native_raf_start(raf->GetRaf());
+		}
+	}
+}
 
-    tmpl->Set(
-            ConvertToV8String(isolate, "configure"),
-            v8::FunctionTemplate::New(isolate, &Configure));
 
-    tmpl->Set(
-            ConvertToV8String(isolate, "unconfigure"),
-            v8::FunctionTemplate::New(isolate, &UnConfigure));
+void GPUCanvasContextImpl::StopRaf() {
+	auto raf = this->GetRaf();
+	if (raf != nullptr) {
+		if (canvas_native_raf_get_started(raf->GetRaf())) {
+			canvas_native_raf_stop(raf->GetRaf());
+		}
+	}
+}
 
-    tmpl->Set(
-            ConvertToV8String(isolate, "getCurrentTexture"),
-            v8::FunctionTemplate::New(isolate, &GetCurrentTexture));
+void GPUCanvasContextImpl::SetRaf(std::shared_ptr<RafImpl> raf) {
+	this->raf_ = std::move(raf);
+}
 
-    tmpl->Set(
-            ConvertToV8String(isolate, "presentSurface"),
-            v8::FunctionTemplate::New(isolate, &PresentSurface));
+RafImpl *GPUCanvasContextImpl::GetRaf() {
+	return this->raf_.get();
+}
 
-    tmpl->Set(
-            ConvertToV8String(isolate, "getCapabilities"),
-            v8::FunctionTemplate::New(isolate, &GetCapabilities));
 
-    tmpl->Set(
-            ConvertToV8String(isolate, "__toDataURL"),
-            v8::FunctionTemplate::New(isolate, &__ToDataURL));
+void GPUCanvasContextImpl::__StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+	GPUCanvasContextImpl *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	ptr->StartRaf();
+	
+}
 
-    cache->GPUCanvasContextTmpl =
-            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
-    return ctorTmpl;
+void GPUCanvasContextImpl::__StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+	GPUCanvasContextImpl *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	ptr->StopRaf();
+	
 }
 
-void GPUCanvasContextImpl::Configure(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    GPUCanvasContextImpl *ptr = GetPointer(args.This());
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
-    auto optionsValue = args[0];
-    if (ptr == nullptr) {
-        return;
-    }
-
-    if (optionsValue->IsNullOrUndefined() || !optionsValue->IsObject()) {
-        return;
-    }
-
-    auto options = optionsValue.As<v8::Object>();
-
-    v8::Local<v8::Value> deviceValue;
-
-    options->Get(context, ConvertToV8String(isolate, "device")).ToLocal(
-            &deviceValue);
-
-
-    if (deviceValue->IsNullOrUndefined() || !deviceValue->IsObject()) {
-        return;
-    }
-
-    auto device = GPUDeviceImpl::GetPointer(deviceValue.As<v8::Object>());
-
-    if (device == nullptr) { return; }
-
-    CanvasGPUSurfaceConfiguration config{};
-    config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeOpaque;
-    config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifo;
-    config.view_formats = nullptr;
-    config.view_formats_size = 0;
-    config.usage = 0x10;
-    config.format = CanvasOptionalGPUTextureFormat{
-            CanvasOptionalGPUTextureFormatNone
-    };
-    config.size = nullptr;
-
-
-    v8::Local<v8::Value> formatValue;
-
-    if (options->Get(context, ConvertToV8String(isolate, "format")).ToLocal(
-            &formatValue)) {
-        auto format = ConvertFromV8String(isolate, formatValue);
-        config.format = canvas_native_webgpu_enum_string_to_gpu_texture(format.c_str());
-    }
-
-
-    v8::Local<v8::Value> usageValue;
-    options->Get(context, ConvertToV8String(isolate, "usage")).ToLocal(
-            &usageValue);
-
-    if (!usageValue.IsEmpty() && usageValue->IsUint32()) {
-        config.usage = usageValue->Uint32Value(context).ToChecked();
-    }
-
-
-    v8::Local<v8::Value> presentModeValue;
-
-    if (options->Get(context, ConvertToV8String(isolate, "presentMode")).ToLocal(
-            &presentModeValue)) {
-        if (presentModeValue->IsString()) {
-            auto presentMode = ConvertFromV8String(isolate, presentModeValue);
-            if (strcmp(presentMode.c_str(), "autoVsync") == 0) {
-                config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeAutoVsync;
-            } else if (strcmp(presentMode.c_str(), "autoNoVsync") == 0) {
-                config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeAutoNoVsync;
-            } else if (strcmp(presentMode.c_str(), "fifo") == 0) {
-                config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifo;
-            } else if (strcmp(presentMode.c_str(), "fifoRelaxed") == 0) {
-                config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifoRelaxed;
-            } else if (strcmp(presentMode.c_str(), "immediate") == 0) {
-                config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeImmediate;
-            } else if (strcmp(presentMode.c_str(), "mailbox") == 0) {
-                config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeMailbox;
-            }
-
-        } else if (presentModeValue->IsInt32()) {
-            config.presentMode = (CanvasGPUPresentMode) presentModeValue->Int32Value(
-                    context).ToChecked();
-        }
-    }
-
-
-    v8::Local<v8::Value> alphaModeValue;
-
-    if (options->Get(context, ConvertToV8String(isolate, "alphaMode")).ToLocal(
-            &alphaModeValue)) {
-        if (alphaModeValue->IsString()) {
-            auto alphaMode = ConvertFromV8String(isolate, alphaModeValue);
-            if (strcmp(alphaMode.c_str(), "premultiplied") == 0) {
-                config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModePreMultiplied;
-            } else if (strcmp(alphaMode.c_str(), "opaque") == 0) {
-                config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeOpaque;
-            } else if (strcmp(alphaMode.c_str(), "postmultiplied") == 0) {
-                config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModePostMultiplied;
-            } else if (strcmp(alphaMode.c_str(), "inherit") == 0) {
-                config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeInherit;
-            } else if (strcmp(alphaMode.c_str(), "auto") == 0) {
-                config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeAuto;
-            }
-        } else if (alphaModeValue->IsInt32()) {
-            config.alphaMode = (CanvasGPUSurfaceAlphaMode) alphaModeValue->Int32Value(
-                    context).ToChecked();
-        }
 
-    }
+void GPUCanvasContextImpl::GetContinuousRenderMode(v8::Local<v8::String> property,
+																									 const v8::PropertyCallbackInfo<v8::Value> &info) {
+	GPUCanvasContextImpl *ptr = GetPointer(info.This());
+	if (ptr == nullptr) {
+		info.GetReturnValue().Set(false);
+		return;
+	}
+	info.GetReturnValue().Set(ptr->continuousRender_);
+}
 
+void GPUCanvasContextImpl::SetContinuousRenderMode(v8::Local<v8::String> property,
+																									 v8::Local<v8::Value> value,
+																									 const v8::PropertyCallbackInfo<void> &info) {
+	GPUCanvasContextImpl *ptr = GetPointer(info.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	auto isolate = info.GetIsolate();
+	auto val = value->BooleanValue(isolate);
+	if (val == ptr->continuousRender_) {
+		return;
+	}
+	if (val) {
+		ptr->StartRaf();
+	} else {
+		ptr->StopRaf();
+	}
+	ptr->continuousRender_ = val;
+}
 
-    v8::Local<v8::Value> sizeValue;
-    options->Get(context, ConvertToV8String(isolate, "size")).ToLocal(
-            &sizeValue);
 
-    CanvasExtent3d size = ParseExtent3d(isolate, sizeValue);
 
-    if (size.width > 0) {
-        config.size = &size;
-    }
-
-    canvas_native_webgpu_context_configure(ptr->GetContext(), device->GetGPUDevice(), &config);
+v8::Local<v8::FunctionTemplate> GPUCanvasContextImpl::GetCtor(v8::Isolate *isolate) {
+	auto cache = Caches::Get(isolate);
+	auto ctor = cache->GPUCanvasContextTmpl.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, "GPUCanvasContext"));
+	
+	auto tmpl = ctorTmpl->InstanceTemplate();
+	tmpl->SetInternalFieldCount(2);
+	
+	SetFastMethod(isolate, tmpl, "__startRaf", __StartRaf, &fast_start_raf_,
+								v8::Local<v8::Value>());
+	
+	SetFastMethod(isolate, tmpl, "__stopRaf", __StopRaf, &fast_stop_raf_,
+								v8::Local<v8::Value>());
+	
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "configure"),
+						v8::FunctionTemplate::New(isolate, &Configure));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "unconfigure"),
+						v8::FunctionTemplate::New(isolate, &UnConfigure));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "getCurrentTexture"),
+						v8::FunctionTemplate::New(isolate, &GetCurrentTexture));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "presentSurface"),
+						v8::FunctionTemplate::New(isolate, &PresentSurface));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "getCapabilities"),
+						v8::FunctionTemplate::New(isolate, &GetCapabilities));
+	
+	tmpl->Set(
+						ConvertToV8String(isolate, "__toDataURL"),
+						v8::FunctionTemplate::New(isolate, &__ToDataURL));
+	
+	tmpl->SetAccessor(ConvertToV8String(isolate, "continuousRenderMode"), GetContinuousRenderMode,
+										SetContinuousRenderMode);
+	
+	cache->GPUCanvasContextTmpl =
+	std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+	return ctorTmpl;
+}
 
+void GPUCanvasContextImpl::Configure(const v8::FunctionCallbackInfo<v8::Value> &args) {
+	GPUCanvasContextImpl *ptr = GetPointer(args.This());
+	auto isolate = args.GetIsolate();
+	auto context = isolate->GetCurrentContext();
+	auto optionsValue = args[0];
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	if (optionsValue->IsNullOrUndefined() || !optionsValue->IsObject()) {
+		return;
+	}
+	
+	auto options = optionsValue.As<v8::Object>();
+	
+	v8::Local<v8::Value> deviceValue;
+	
+	options->Get(context, ConvertToV8String(isolate, "device")).ToLocal(
+																																			&deviceValue);
+	
+	
+	if (deviceValue->IsNullOrUndefined() || !deviceValue->IsObject()) {
+		return;
+	}
+	
+	auto device = GPUDeviceImpl::GetPointer(deviceValue.As<v8::Object>());
+	
+	if (device == nullptr) { return; }
+	
+	CanvasGPUSurfaceConfiguration config{};
+	config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeOpaque;
+	config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifo;
+	config.view_formats = nullptr;
+	config.view_formats_size = 0;
+	config.usage = 0x10;
+	config.format = CanvasOptionalGPUTextureFormat{
+		CanvasOptionalGPUTextureFormatNone
+	};
+	config.size = nullptr;
+	
+	
+	v8::Local<v8::Value> formatValue;
+	
+	if (options->Get(context, ConvertToV8String(isolate, "format")).ToLocal(
+																																					&formatValue)) {
+																																						auto format = ConvertFromV8String(isolate, formatValue);
+																																						config.format = canvas_native_webgpu_enum_string_to_gpu_texture(format.c_str());
+																																					}
+	
+	
+	v8::Local<v8::Value> usageValue;
+	options->Get(context, ConvertToV8String(isolate, "usage")).ToLocal(
+																																		 &usageValue);
+	
+	if (!usageValue.IsEmpty() && usageValue->IsUint32()) {
+		config.usage = usageValue->Uint32Value(context).ToChecked();
+	}
+	
+	
+	v8::Local<v8::Value> presentModeValue;
+	
+	if (options->Get(context, ConvertToV8String(isolate, "presentMode")).ToLocal(
+																																							 &presentModeValue)) {
+																																								 if (presentModeValue->IsString()) {
+																																									 auto presentMode = ConvertFromV8String(isolate, presentModeValue);
+																																									 if (strcmp(presentMode.c_str(), "autoVsync") == 0) {
+																																										 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeAutoVsync;
+																																									 } else if (strcmp(presentMode.c_str(), "autoNoVsync") == 0) {
+																																										 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeAutoNoVsync;
+																																									 } else if (strcmp(presentMode.c_str(), "fifo") == 0) {
+																																										 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifo;
+																																									 } else if (strcmp(presentMode.c_str(), "fifoRelaxed") == 0) {
+																																										 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeFifoRelaxed;
+																																									 } else if (strcmp(presentMode.c_str(), "immediate") == 0) {
+																																										 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeImmediate;
+																																									 } else if (strcmp(presentMode.c_str(), "mailbox") == 0) {
+																																										 config.presentMode = CanvasGPUPresentMode::CanvasGPUPresentModeMailbox;
+																																									 }
+																																									 
+																																								 } else if (presentModeValue->IsInt32()) {
+																																									 config.presentMode = (CanvasGPUPresentMode) presentModeValue->Int32Value(
+																																																																														context).ToChecked();
+																																								 }
+																																							 }
+	
+	
+	v8::Local<v8::Value> alphaModeValue;
+	
+	if (options->Get(context, ConvertToV8String(isolate, "alphaMode")).ToLocal(
+																																						 &alphaModeValue)) {
+																																							 if (alphaModeValue->IsString()) {
+																																								 auto alphaMode = ConvertFromV8String(isolate, alphaModeValue);
+																																								 if (strcmp(alphaMode.c_str(), "premultiplied") == 0) {
+																																									 config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModePreMultiplied;
+																																								 } else if (strcmp(alphaMode.c_str(), "opaque") == 0) {
+																																									 config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeOpaque;
+																																								 } else if (strcmp(alphaMode.c_str(), "postmultiplied") == 0) {
+																																									 config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModePostMultiplied;
+																																								 } else if (strcmp(alphaMode.c_str(), "inherit") == 0) {
+																																									 config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeInherit;
+																																								 } else if (strcmp(alphaMode.c_str(), "auto") == 0) {
+																																									 config.alphaMode = CanvasGPUSurfaceAlphaMode::CanvasGPUSurfaceAlphaModeAuto;
+																																								 }
+																																							 } else if (alphaModeValue->IsInt32()) {
+																																								 config.alphaMode = (CanvasGPUSurfaceAlphaMode) alphaModeValue->Int32Value(
+																																																																													 context).ToChecked();
+																																							 }
+																																							 
+																																						 }
+	
+	
+	v8::Local<v8::Value> sizeValue;
+	options->Get(context, ConvertToV8String(isolate, "size")).ToLocal(
+																																		&sizeValue);
+	
+	CanvasExtent3d size = ParseExtent3d(isolate, sizeValue);
+	
+	if (size.width > 0) {
+		config.size = &size;
+	}
+	
+	canvas_native_webgpu_context_configure(ptr->GetContext(), device->GetGPUDevice(), &config);
+	
 }
 
 void GPUCanvasContextImpl::UnConfigure(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    GPUCanvasContextImpl *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
-
-    canvas_native_webgpu_context_unconfigure(ptr->GetContext());
-
+	GPUCanvasContextImpl *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	
+	canvas_native_webgpu_context_unconfigure(ptr->GetContext());
+	
 }
 
 void GPUCanvasContextImpl::__ToDataURL(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    GPUCanvasContextImpl *ptr = GetPointer(args.This());
-
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
-
-
-    std::string type("image/png");
-    int quality = 92;
-    if (args[0]->IsString()) {
-        type = ConvertFromV8String(isolate, args[0]);
-    }
-
-    if (args[1]->IsNumber()) {
-        quality = (int) (args[1]->NumberValue(context).ToChecked() * 100);
-    }
-
-    auto deviceType = GetNativeType(args[2]);
-    auto textureType = GetNativeType(args[3]);
-
-    if (deviceType == NativeType::GPUDevice) {
-        auto device = GPUDeviceImpl::GetPointer(args[2].As<v8::Object>());
-        char* data = nullptr;
-        if(textureType == NativeType::GPUTexture){
-            auto texture = GPUTextureImpl::GetPointer(args[3].As<v8::Object>());
-            data = canvas_native_webgpu_to_data_url_with_texture(
-                    ptr->GetContext(), device->GetGPUDevice(), texture->GetTexture(),
-                                                                 type.c_str(),
-                    quality);
-        }else {
-            data = canvas_native_webgpu_to_data_url(
-                    ptr->GetContext(), device->GetGPUDevice(), type.c_str(),
-                    quality);
-            
-        }
-        
-        if(data == nullptr){
-            args.GetReturnValue().Set(ConvertToV8String(isolate, "data:,"));
-            return;
-        }
-
-        auto value = new OneByteStringResource((char *) data);
-        auto ret = v8::String::NewExternalOneByte(isolate, value);
-        args.GetReturnValue().Set(ret.ToLocalChecked());
-    } else {
-        args.GetReturnValue().Set(ConvertToV8String(isolate, "data:,"));
-    }
-
-
+	GPUCanvasContextImpl *ptr = GetPointer(args.This());
+	
+	auto isolate = args.GetIsolate();
+	auto context = isolate->GetCurrentContext();
+	
+	
+	std::string type("image/png");
+	float quality = 0.92;
+	if (args[0]->IsString()) {
+		type = ConvertFromV8String(isolate, args[0]);
+	}
+	
+	if (args[1]->IsNumber()) {
+		quality = (float) args[1]->NumberValue(context).ToChecked();
+	}
+	
+	
+	auto data = canvas_native_webgpu_to_data_url_with_fallback(
+																														 ptr->GetContext(), type.c_str(),
+																														 quality);
+	
+	
+	auto value = new OneByteStringResource((char *) data);
+	auto ret = v8::String::NewExternalOneByte(isolate, value);
+	args.GetReturnValue().Set(ret.ToLocalChecked());
+	
 }
 
 void GPUCanvasContextImpl::GetCurrentTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    GPUCanvasContextImpl *ptr = GetPointer(args.This());
-    auto isolate = args.GetIsolate();
-    if (ptr == nullptr) {
-        args.GetReturnValue().SetUndefined();
-        return;
-    }
-
-    auto ctx = ptr->GetContext();
-
-    auto texture = canvas_native_webgpu_context_get_current_texture(ctx);
-
-    if (texture != nullptr) {
-        auto status = canvas_native_webgpu_texture_get_status(texture);
-        if (status == SurfaceGetCurrentTextureStatusSuccess) {
-            auto textureImpl = new GPUTextureImpl(texture);
-            auto ret = GPUTextureImpl::NewInstance(isolate, textureImpl);
-            args.GetReturnValue().Set(ret);
-        } else {
-            canvas_native_webgpu_texture_release(texture);
-            args.GetReturnValue().SetNull();
-        }
-        return;
-    }
-
-    args.GetReturnValue().SetUndefined();
+	GPUCanvasContextImpl *ptr = GetPointer(args.This());
+	auto isolate = args.GetIsolate();
+	if (ptr == nullptr) {
+		args.GetReturnValue().SetUndefined();
+		return;
+	}
+	
+	auto ctx = ptr->GetContext();
+	
+	auto texture = canvas_native_webgpu_context_get_current_texture(ctx);
+	
+	if (texture != nullptr) {
+		auto status = canvas_native_webgpu_texture_get_status(texture);
+		if (status == SurfaceGetCurrentTextureStatusSuccess) {
+			auto textureImpl = new GPUTextureImpl(texture);
+			auto ret = GPUTextureImpl::NewInstance(isolate, textureImpl);
+			args.GetReturnValue().Set(ret);
+		} else {
+			canvas_native_webgpu_texture_release(texture);
+			args.GetReturnValue().SetNull();
+		}
+		return;
+	}
+	
+	args.GetReturnValue().SetUndefined();
 }
 
 void GPUCanvasContextImpl::PresentSurface(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    GPUCanvasContextImpl *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
-    auto textureVal = args[0];
-    if (!textureVal.IsEmpty() && textureVal->IsObject()) {
-        auto texture = GPUTextureImpl::GetPointer(textureVal.As<v8::Object>());
-        if (texture != nullptr) {
-            auto ctx = ptr->GetContext();
-
-            canvas_native_webgpu_context_present_surface(ctx, texture->GetTexture());
-        }
-    }
-
+	GPUCanvasContextImpl *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	auto context = ptr->GetContext();
+	if(canvas_native_webgpu_context_has_current_texture(context) && !canvas_native_webgpu_context_has_surface_presented(context)){
+		auto texture = canvas_native_webgpu_context_get_current_texture(context);
+		if(texture != nullptr){
+			canvas_native_webgpu_context_present_surface(context, texture);
+		}
+	}
+	
+	
 }
 
 void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    GPUCanvasContextImpl *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
-    auto adapterVal = args[0];
-    auto ret = v8::Object::New(isolate);
-
-    if (!adapterVal.IsEmpty() && adapterVal->IsObject()) {
-        auto adapter = GPUAdapterImpl::GetPointer(adapterVal.As<v8::Object>());
-        auto ctx = ptr->GetContext();
-
-        if (adapter != nullptr) {
-            auto cap = canvas_native_webgpu_context_get_capabilities(ctx, adapter->GetGPUAdapter());
-            auto formats_len = canvas_native_string_buffer_get_length(cap->formats);
-            auto formats = v8::Array::New(isolate, (int) formats_len);
-            for (int i = 0; i < formats_len; i++) {
-                auto format = canvas_native_string_buffer_get_value_at(cap->formats, i);
-                formats->Set(context, i, ConvertToV8String(isolate, format)).FromJust();
-                canvas_native_string_destroy(format);
-            }
-
-            auto present_modes_len = canvas_native_string_buffer_get_length(cap->present_modes);
-            auto present_modes = v8::Array::New(isolate, (int) present_modes_len);
-
-
-            for (int i = 0; i < present_modes_len; i++) {
-                auto mode = canvas_native_string_buffer_get_value_at(cap->present_modes, i);
-                present_modes->Set(context, i, ConvertToV8String(isolate, mode)).FromJust();
-                canvas_native_string_destroy(mode);
-            }
-
-            auto alpha_modes_len = canvas_native_string_buffer_get_length(cap->alpha_modes);
-            auto alpha_modes = v8::Array::New(isolate, (int) alpha_modes_len);
-
-
-            for (int i = 0; i < alpha_modes_len; i++) {
-                auto mode = canvas_native_string_buffer_get_value_at(cap->alpha_modes, i);
-                alpha_modes->Set(context, i, ConvertToV8String(isolate, mode)).FromJust();
-                canvas_native_string_destroy(mode);
-            }
-
-            ret->Set(context, ConvertToV8String(isolate, "format"), formats).FromJust();
-            ret->Set(context, ConvertToV8String(isolate, "presentModes"), present_modes).FromJust();
-            ret->Set(context, ConvertToV8String(isolate, "alphaModes"), alpha_modes).FromJust();
-            ret->Set(context, ConvertToV8String(isolate, "usages"),
-                     v8::Uint32::NewFromUnsigned(isolate, cap->usages)).FromJust();
-
-            canvas_native_webgpu_struct_surface_capabilities_release(cap);
-
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-
-
-    }
-
-    ret->Set(context, ConvertToV8String(isolate, "format"), v8::Array::New(isolate)).FromJust();
-    ret->Set(context, ConvertToV8String(isolate, "presentModes"),
-             v8::Array::New(isolate)).FromJust();
-    ret->Set(context, ConvertToV8String(isolate, "alphaModes"), v8::Array::New(isolate)).FromJust();
-    ret->Set(context, ConvertToV8String(isolate, "usages"), v8::Uint32::New(isolate, 0)).FromJust();
-    args.GetReturnValue().Set(ret);
+	GPUCanvasContextImpl *ptr = GetPointer(args.This());
+	if (ptr == nullptr) {
+		return;
+	}
+	auto isolate = args.GetIsolate();
+	auto context = isolate->GetCurrentContext();
+	auto adapterVal = args[0];
+	auto ret = v8::Object::New(isolate);
+	
+	if (!adapterVal.IsEmpty() && adapterVal->IsObject()) {
+		auto adapter = GPUAdapterImpl::GetPointer(adapterVal.As<v8::Object>());
+		auto ctx = ptr->GetContext();
+		
+		if (adapter != nullptr) {
+			auto cap = canvas_native_webgpu_context_get_capabilities(ctx, adapter->GetGPUAdapter());
+			auto formats_len = canvas_native_string_buffer_get_length(cap->formats);
+			auto formats = v8::Array::New(isolate, (int) formats_len);
+			for (int i = 0; i < formats_len; i++) {
+				auto format = canvas_native_string_buffer_get_value_at(cap->formats, i);
+				formats->Set(context, i, ConvertToV8String(isolate, format)).FromJust();
+				canvas_native_string_destroy(format);
+			}
+			
+			auto present_modes_len = canvas_native_string_buffer_get_length(cap->present_modes);
+			auto present_modes = v8::Array::New(isolate, (int) present_modes_len);
+			
+			
+			for (int i = 0; i < present_modes_len; i++) {
+				auto mode = canvas_native_string_buffer_get_value_at(cap->present_modes, i);
+				present_modes->Set(context, i, ConvertToV8String(isolate, mode)).FromJust();
+				canvas_native_string_destroy(mode);
+			}
+			
+			auto alpha_modes_len = canvas_native_string_buffer_get_length(cap->alpha_modes);
+			auto alpha_modes = v8::Array::New(isolate, (int) alpha_modes_len);
+			
+			
+			for (int i = 0; i < alpha_modes_len; i++) {
+				auto mode = canvas_native_string_buffer_get_value_at(cap->alpha_modes, i);
+				alpha_modes->Set(context, i, ConvertToV8String(isolate, mode)).FromJust();
+				canvas_native_string_destroy(mode);
+			}
+			
+			ret->Set(context, ConvertToV8String(isolate, "format"), formats).FromJust();
+			ret->Set(context, ConvertToV8String(isolate, "presentModes"), present_modes).FromJust();
+			ret->Set(context, ConvertToV8String(isolate, "alphaModes"), alpha_modes).FromJust();
+			ret->Set(context, ConvertToV8String(isolate, "usages"),
+							 v8::Uint32::NewFromUnsigned(isolate, cap->usages)).FromJust();
+			
+			canvas_native_webgpu_struct_surface_capabilities_release(cap);
+			
+			args.GetReturnValue().Set(ret);
+			return;
+		}
+		
+		
+	}
+	
+	ret->Set(context, ConvertToV8String(isolate, "format"), v8::Array::New(isolate)).FromJust();
+	ret->Set(context, ConvertToV8String(isolate, "presentModes"),
+					 v8::Array::New(isolate)).FromJust();
+	ret->Set(context, ConvertToV8String(isolate, "alphaModes"), v8::Array::New(isolate)).FromJust();
+	ret->Set(context, ConvertToV8String(isolate, "usages"), v8::Uint32::New(isolate, 0)).FromJust();
+	args.GetReturnValue().Set(ret);
+}
+
+
+void GPUCanvasContextImpl::Flush() {
+	auto context = this->GetContext();
+	if(canvas_native_webgpu_context_has_current_texture(context) && !canvas_native_webgpu_context_has_surface_presented(context)){
+		auto texture = canvas_native_webgpu_context_get_current_texture(context);
+		if(texture != nullptr){
+			canvas_native_webgpu_context_present_surface(context, texture);
+		}
+	}
+}
+
+void GPUCanvasContextImpl::Flush(intptr_t context) {
+	auto ctx = reinterpret_cast<GPUCanvasContextImpl *>(reinterpret_cast<intptr_t *>(context));
+	if (ctx != nullptr) {
+		ctx->Flush();
+	}
 }