@nativescript/canvas 2.0.0-beta.9 → 2.0.0-webgpu.0

package/platforms/ios/src/cpp/CanvasJSIModule.cpp

@@ -7,7 +7,121 @@
 #include "JSIRuntime.h"
 #include "JSIReadFileCallback.h"
 #include "Helpers.h"
-#include "PerIsolateData.h"
+
+struct GLOptions {
+    int32_t version;
+    bool alpha;
+    bool antialias;
+    bool depth;
+    bool failIfMajorPerformanceCaveat;
+    int32_t powerPreference;
+    bool premultipliedAlpha;
+    bool preserveDrawingBuffer;
+    bool stencil;
+    bool desynchronized;
+    bool xrCompatible;
+
+public:
+    GLOptions() {
+        this->version = 0;
+        this->alpha = true;
+        this->antialias = true;
+        this->depth = true;
+        this->failIfMajorPerformanceCaveat = false;
+        this->powerPreference = 0;
+        this->premultipliedAlpha = true;
+        this->preserveDrawingBuffer = false;
+        this->stencil = false;
+        this->desynchronized = false;
+        this->xrCompatible = false;
+    }
+
+    void parseGLOptions(const v8::FunctionCallbackInfo<v8::Value> &args) {
+        auto configValue = args[0];
+
+        if (!(!configValue->IsNullOrUndefined() && configValue->IsObject())) {
+            return;
+        }
+
+        auto isolate = args.GetIsolate();
+        auto context = isolate->GetCurrentContext();
+        auto config = configValue.As<v8::Object>();
+
+        v8::Local<v8::Value> versionValue;
+
+        config->Get(context, ConvertToV8String(isolate, "version")).ToLocal(&versionValue);
+
+        if (!versionValue.IsEmpty() && versionValue->IsInt32()) {
+            versionValue->Int32Value(context).To(&this->version);
+        }
+
+        v8::Local<v8::Value> alphaValue;
+
+        config->Get(context, ConvertToV8String(isolate, "alpha")).ToLocal(&alphaValue);
+        if (!alphaValue.IsEmpty() && alphaValue->IsBoolean()) {
+            this->alpha = alphaValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> antialiasValue;
+        config->Get(context, ConvertToV8String(isolate, "antialias")).ToLocal(
+                &antialiasValue);
+        if (!antialiasValue.IsEmpty() && antialiasValue->IsBoolean()) {
+            this->antialias = antialiasValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> failIfMajorPerformanceCaveatValue;
+        config->Get(context, ConvertToV8String(isolate, "failIfMajorPerformanceCaveat")).ToLocal(
+                &failIfMajorPerformanceCaveatValue);
+        if (!failIfMajorPerformanceCaveatValue.IsEmpty() &&
+            failIfMajorPerformanceCaveatValue->IsBoolean()) {
+            this->failIfMajorPerformanceCaveat = failIfMajorPerformanceCaveatValue->BooleanValue(
+                    isolate);
+        }
+
+        v8::Local<v8::Value> powerPreferenceValue;
+        config->Get(context, ConvertToV8String(isolate, "powerPreference")).ToLocal(
+                &powerPreferenceValue);
+        if (!powerPreferenceValue.IsEmpty() && powerPreferenceValue->IsInt32()) {
+            powerPreferenceValue->Int32Value(context).To(&this->powerPreference);
+        }
+
+        v8::Local<v8::Value> premultipliedAlphaValue;
+        config->Get(context,
+                    ConvertToV8String(isolate, "premultipliedAlpha")).ToLocal(
+                &premultipliedAlphaValue);
+        if (!premultipliedAlphaValue.IsEmpty() && premultipliedAlphaValue->IsBoolean()) {
+            this->premultipliedAlpha = premultipliedAlphaValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> preserveDrawingBufferValue;
+        config->Get(context,
+                    ConvertToV8String(isolate, "preserveDrawingBuffer")).ToLocal(
+                &preserveDrawingBufferValue);
+        if (!preserveDrawingBufferValue.IsEmpty() && preserveDrawingBufferValue->IsBoolean()) {
+            this->preserveDrawingBuffer = preserveDrawingBufferValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> stencilValue;
+        config->Get(context, ConvertToV8String(isolate, "stencil")).ToLocal(&stencilValue);
+        if (!stencilValue.IsEmpty() && stencilValue->IsBoolean()) {
+            this->stencil = stencilValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> desynchronizedValue;
+        config->Get(context, ConvertToV8String(isolate, "desynchronized")).ToLocal(
+                &desynchronizedValue);
+        if (!desynchronizedValue.IsEmpty() && desynchronizedValue->IsBoolean()) {
+            this->desynchronized = desynchronizedValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> xrCompatibleValue;
+        config->Get(context, ConvertToV8String(isolate, "xrCompatible")).ToLocal(
+                &xrCompatibleValue);
+        if (!xrCompatibleValue.IsEmpty() && xrCompatibleValue->IsBoolean()) {
+            this->xrCompatible = xrCompatibleValue->BooleanValue(isolate);
+        }
+    }
+};
 
 void CanvasJSIModule::install(v8::Isolate *isolate) {
 
@@ -35,47 +149,53 @@ void CanvasJSIModule::install(v8::Isolate *isolate) {
         CanvasPattern::Init(canvasMod, isolate);
         MatrixImpl::Init(canvasMod, isolate);
         TextMetricsImpl::Init(canvasMod, isolate);
-        URLImpl::Init(canvasMod, isolate);
 
-        // always use the last slot
-        auto lastSlot = isolate->GetNumberOfDataSlots() - 1;
-        auto data = new PerIsolateData(isolate);
-        isolate->SetData(lastSlot, data);
 
-        v8Global->Set(context, ConvertToV8String(isolate, "CanvasModule"), canvasMod);
+        GPUImpl::Init(canvasMod, isolate);
+        GPUSupportedLimitsImpl::Init(canvasMod, isolate);
+        GPUDeviceImpl::Init(canvasMod, isolate);
+        GPUQueueImpl::Init(canvasMod, isolate);
+
+        v8Global->Set(context, ConvertToV8String(isolate, "CanvasModule"), canvasMod).FromJust();
         canvasMod->Set(context, ConvertToV8String(isolate, "create2DContext"),
                        v8::FunctionTemplate::New(isolate, &Create2DContext)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
         canvasMod->Set(context, ConvertToV8String(isolate, "createImageBitmap"),
                        v8::FunctionTemplate::New(isolate, &CreateImageBitmap)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
         canvasMod->Set(context, ConvertToV8String(isolate, "create2DContextWithPointer"),
                        v8::FunctionTemplate::New(isolate, &Create2DContextWithPointer)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
+
+        canvasMod->Set(context, ConvertToV8String(isolate, "createWebGPUContextWithPointer"),
+                       v8::FunctionTemplate::New(isolate,
+                                                 &CreateWebGPUContextWithPointer)->GetFunction(
+                               context).ToLocalChecked()).FromJust();
+
+
         canvasMod->Set(context, ConvertToV8String(isolate, "readFile"),
                        v8::FunctionTemplate::New(isolate, &ReadFile)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
 
         canvasMod->Set(context, ConvertToV8String(isolate, "createWebGLContext"),
                        v8::FunctionTemplate::New(isolate, &CreateWebGLContext)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
 
         canvasMod->Set(context, ConvertToV8String(isolate, "createWebGL2Context"),
                        v8::FunctionTemplate::New(isolate, &CreateWebGL2Context)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
 
 
         canvasMod->Set(context, ConvertToV8String(isolate, "__addFontFamily"),
                        v8::FunctionTemplate::New(isolate, &AddFontFamily)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
 
         global->Set(context,
-                    ConvertToV8String(isolate, "CanvasModule"), canvasMod);
+                    ConvertToV8String(isolate, "CanvasModule"), canvasMod).FromJust();
 
     }
 }
 
-
 void CanvasJSIModule::AddFontFamily(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
@@ -807,7 +927,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
         }
     }
 
-    auto type = GetNativeType( image);
+    auto type = GetNativeType(image);
 
     if (len == 1 || len == 2) {
         if (len == 2) {
@@ -1190,404 +1310,209 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
 }
 
 void CanvasJSIModule::CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto configValue = args[0];
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
-    if (!configValue->IsNullOrUndefined() && configValue->IsObject()) {
-        auto config = configValue.As<v8::Object>();
-        std::string version("none");
-        auto alpha = true;
-        auto antialias = true;
-        auto depth = true;
-        auto fail_if_major_performance_caveat = false;
-        std::string power_preference("default");
-        auto premultiplied_alpha = true;
-        auto preserve_drawing_buffer = false;
-        auto stencil = false;
-        auto desynchronized = false;
-        auto xr_compatible = false;
-
-        auto last = isolate->GetNumberOfDataSlots() - 1;
-        auto data = isolate->GetData(last);
-
-        if (data != nullptr) {
-            auto consts = static_cast<PerIsolateData *>(data);
-
-            v8::Local<v8::Value> versionValue;
-
-            config->Get(context, consts->VERSION_PERSISTENT->Get(isolate)).ToLocal(&versionValue);
-
-            if (!versionValue.IsEmpty() && versionValue->IsString()) {
-                version = ConvertFromV8String(isolate, versionValue);
-            }
-
-            v8::Local<v8::Value> alphaValue;
-
-            config->Get(context, consts->ALPHA_PERSISTENT->Get(isolate)).ToLocal(&alphaValue);
-            if (!alphaValue.IsEmpty() && alphaValue->IsBoolean()) {
-                alpha = alphaValue->BooleanValue(isolate);
-            }
-
-            v8::Local<v8::Value> antialiasValue;
-            config->Get(context, consts->ANTIALIAS_PERSISTENT->Get(isolate)).ToLocal(
-                    &antialiasValue);
-            if (!antialiasValue.IsEmpty() && antialiasValue->IsBoolean()) {
-                antialias = antialiasValue->BooleanValue(isolate);
-            }
-
-            v8::Local<v8::Value> failIfMajorPerformanceCaveatValue;
-            config->Get(context,
-                        consts->FAIL_IF_MAJOR_PERFORMANCE_CAVEAT_PERSISTENT->Get(isolate)).ToLocal(
-                    &failIfMajorPerformanceCaveatValue);
-            if (!failIfMajorPerformanceCaveatValue.IsEmpty() &&
-                failIfMajorPerformanceCaveatValue->IsBoolean()) {
-                fail_if_major_performance_caveat = failIfMajorPerformanceCaveatValue->BooleanValue(
-                        isolate);
-            }
-
-            v8::Local<v8::Value> powerPreferenceValue;
-            config->Get(context, consts->POWER_PREFERENCE_PERSISTENT->Get(isolate)).ToLocal(
-                    &powerPreferenceValue);
-            if (!powerPreferenceValue.IsEmpty() && powerPreferenceValue->IsString()) {
-                power_preference = ConvertFromV8String(isolate, powerPreferenceValue);
-            }
-
-            v8::Local<v8::Value> premultipliedAlphaValue;
-            config->Get(context,
-                        consts->PREMULTIPLIED_ALPHA_PERSISTENT->Get(isolate)).ToLocal(
-                    &premultipliedAlphaValue);
-            if (!premultipliedAlphaValue.IsEmpty() && premultipliedAlphaValue->IsBoolean()) {
-                premultiplied_alpha = premultipliedAlphaValue->BooleanValue(isolate);
-            }
-
-            v8::Local<v8::Value> preserveDrawingBufferValue;
-            config->Get(context,
-                        consts->PRESERVE_DRAWING_BUFFER_PERSISTENT->Get(isolate)).ToLocal(
-                    &preserveDrawingBufferValue);
-            if (!preserveDrawingBufferValue.IsEmpty() && preserveDrawingBufferValue->IsBoolean()) {
-                preserve_drawing_buffer = preserveDrawingBufferValue->BooleanValue(isolate);
-            }
-
-            v8::Local<v8::Value> stencilValue;
-            config->Get(context, consts->STENCIL_PERSISTENT->Get(isolate)).ToLocal(&stencilValue);
-            if (!stencilValue.IsEmpty() && stencilValue->IsBoolean()) {
-                stencil = stencilValue->BooleanValue(isolate);
-            }
-
-            v8::Local<v8::Value> desynchronizedValue;
-            config->Get(context, consts->DESYNCHRONIZED_PERSISTENT->Get(isolate)).ToLocal(
-                    &desynchronizedValue);
-            if (!desynchronizedValue.IsEmpty() && desynchronizedValue->IsBoolean()) {
-                desynchronized = desynchronizedValue->BooleanValue(isolate);
-            }
-
-            v8::Local<v8::Value> xrCompatibleValue;
-            config->Get(context,
-                        consts->XR_COMPATIBLE_PERSISTENT->Get(isolate)).ToLocal(&xrCompatibleValue);
-            if (!xrCompatibleValue.IsEmpty() && xrCompatibleValue->IsBoolean()) {
-                xr_compatible = xrCompatibleValue->BooleanValue(isolate);
-            }
-        }
 
+    auto options = GLOptions();
+    options.parseGLOptions(args);
 
-        if (version !=
-            "v1") {
-            args.GetReturnValue().SetNull();
-            return;
-        } else {
-            auto count = args.Length();
-            if (count == 6) {
-                auto ctx = args[1].As<v8::BigInt>()->Int64Value();
-//                auto density = args[2]->NumberValue(context).ToChecked();
-//                auto fontColor = args[3]->NumberValue(context).ToChecked();
-//                auto ppi = args[4]->NumberValue(context).ToChecked();
-//                auto direction = args[5]->NumberValue(context).ToChecked();
-                auto webgl = canvas_native_webgl_create(
-                        ctx,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible
-                );
-
-                auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
-                                                                           new WebGLRenderingContext(
-                                                                                   webgl));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
-            } else if (count == 7) {
-                auto width = args[1]->NumberValue(context).ToChecked();
-                auto height = args[2]->NumberValue(context).ToChecked();
-//                auto density = args[3]->NumberValue(context).ToChecked();
-//                auto fontColor = args[4]->NumberValue(context).ToChecked();
-//                auto ppi = args[5]->NumberValue(context).ToChecked();
-//                auto direction = args[6]->NumberValue(context).ToChecked();
-                auto ctx = canvas_native_webgl_create_no_window(
-                        (int32_t) width,
-                        (int32_t) height,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible,
-                        false
-                );
-
-                auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
-                                                                           new WebGLRenderingContext(
-                                                                                   ctx));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
-
-            } else {
-                auto width = (int32_t) args[1]->NumberValue(context).ToChecked();
-                auto height = (int32_t) args[2]->NumberValue(context).ToChecked();
-
-                auto ctx = canvas_native_webgl_create_no_window(
-                        width,
-                        height,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible,
-                        false
-                );
-
-                auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
-                                                                           new WebGLRenderingContext(
-                                                                                   ctx));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
-            }
-
-        }
+    if (options.version != 1) {
+        args.GetReturnValue().SetNull();
+        return;
     }
-    args.GetReturnValue().SetNull();
-}
 
-void CanvasJSIModule::CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto configValue = args[0];
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    if (!configValue->IsNullOrUndefined() && configValue->IsObject()) {
-        auto config = configValue.As<v8::Object>();
-        std::string version("none");
-        auto alpha = true;
-        auto antialias = true;
-        auto depth = true;
-        auto fail_if_major_performance_caveat = false;
-        std::string power_preference("default");
-        auto premultiplied_alpha = true;
-        auto preserve_drawing_buffer = false;
-        auto stencil = false;
-        auto desynchronized = false;
-        auto xr_compatible = false;
-
 
-        auto last = isolate->GetNumberOfDataSlots() - 1;
-        auto data = isolate->GetData(last);
 
-        if (data != nullptr) {
-            auto consts = static_cast<PerIsolateData *>(data);
-
-            v8::Local<v8::Value> versionValue;
-
-            config->Get(context, consts->VERSION_PERSISTENT->Get(isolate)).ToLocal(&versionValue);
-
-            if (!versionValue.IsEmpty() && versionValue->IsString()) {
-                version = ConvertFromV8String(isolate, versionValue);
-            }
-
-            v8::Local<v8::Value> alphaValue;
+    auto count = args.Length();
+    if (count == 6) {
+        auto ctx = args[1].As<v8::BigInt>()->Int64Value();
+        auto webgl = canvas_native_webgl_create(
+                ctx,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible
+        );
+
+        auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
+                                                                   new WebGLRenderingContext(
+                                                                           webgl));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
+    } else if (count == 7) {
+        auto width = args[1]->NumberValue(context).ToChecked();
+        auto height = args[2]->NumberValue(context).ToChecked();
+        auto ctx = canvas_native_webgl_create_no_window(
+                (int32_t) width,
+                (int32_t) height,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible,
+                false
+        );
+
+        auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
+                                                                   new WebGLRenderingContext(
+                                                                           ctx));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
 
-            config->Get(context, consts->ALPHA_PERSISTENT->Get(isolate)).ToLocal(&alphaValue);
-            if (!alphaValue.IsEmpty() && alphaValue->IsBoolean()) {
-                alpha = alphaValue->BooleanValue(isolate);
-            }
+    } else {
+        auto width = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto height = (int32_t) args[2]->NumberValue(context).ToChecked();
+
+        auto ctx = canvas_native_webgl_create_no_window(
+                width,
+                height,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible,
+                false
+        );
+
+        auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
+                                                                   new WebGLRenderingContext(
+                                                                           ctx));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
+    }
+}
 
-            v8::Local<v8::Value> antialiasValue;
-            config->Get(context, consts->ANTIALIAS_PERSISTENT->Get(isolate)).ToLocal(
-                    &antialiasValue);
-            if (!antialiasValue.IsEmpty() && antialiasValue->IsBoolean()) {
-                antialias = antialiasValue->BooleanValue(isolate);
-            }
+void CanvasJSIModule::CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
-            v8::Local<v8::Value> failIfMajorPerformanceCaveatValue;
-            config->Get(context,
-                        consts->FAIL_IF_MAJOR_PERFORMANCE_CAVEAT_PERSISTENT->Get(isolate)).ToLocal(
-                    &failIfMajorPerformanceCaveatValue);
-            if (!failIfMajorPerformanceCaveatValue.IsEmpty() &&
-                failIfMajorPerformanceCaveatValue->IsBoolean()) {
-                fail_if_major_performance_caveat = failIfMajorPerformanceCaveatValue->BooleanValue(
-                        isolate);
-            }
 
-            v8::Local<v8::Value> powerPreferenceValue;
-            config->Get(context, consts->POWER_PREFERENCE_PERSISTENT->Get(isolate)).ToLocal(
-                    &powerPreferenceValue);
-            if (!powerPreferenceValue.IsEmpty() && powerPreferenceValue->IsString()) {
-                power_preference = ConvertFromV8String(isolate, powerPreferenceValue);
-            }
+    auto options = GLOptions();
+    options.parseGLOptions(args);
 
-            v8::Local<v8::Value> premultipliedAlphaValue;
-            config->Get(context,
-                        consts->PREMULTIPLIED_ALPHA_PERSISTENT->Get(isolate)).ToLocal(
-                    &premultipliedAlphaValue);
-            if (!premultipliedAlphaValue.IsEmpty() && premultipliedAlphaValue->IsBoolean()) {
-                premultiplied_alpha = premultipliedAlphaValue->BooleanValue(isolate);
-            }
+    if (options.version != 2) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
 
-            v8::Local<v8::Value> preserveDrawingBufferValue;
-            config->Get(context,
-                        consts->PRESERVE_DRAWING_BUFFER_PERSISTENT->Get(isolate)).ToLocal(
-                    &preserveDrawingBufferValue);
-            if (!preserveDrawingBufferValue.IsEmpty() && preserveDrawingBufferValue->IsBoolean()) {
-                preserve_drawing_buffer = preserveDrawingBufferValue->BooleanValue(isolate);
-            }
 
-            v8::Local<v8::Value> stencilValue;
-            config->Get(context, consts->STENCIL_PERSISTENT->Get(isolate)).ToLocal(&stencilValue);
-            if (!stencilValue.IsEmpty() && stencilValue->IsBoolean()) {
-                stencil = stencilValue->BooleanValue(isolate);
-            }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-            v8::Local<v8::Value> desynchronizedValue;
-            config->Get(context, consts->DESYNCHRONIZED_PERSISTENT->Get(isolate)).ToLocal(
-                    &desynchronizedValue);
-            if (!desynchronizedValue.IsEmpty() && desynchronizedValue->IsBoolean()) {
-                desynchronized = desynchronizedValue->BooleanValue(isolate);
-            }
 
-            v8::Local<v8::Value> xrCompatibleValue;
-            config->Get(context,
-                        consts->XR_COMPATIBLE_PERSISTENT->Get(isolate)).ToLocal(&xrCompatibleValue);
-            if (!xrCompatibleValue.IsEmpty() && xrCompatibleValue->IsBoolean()) {
-                xr_compatible = xrCompatibleValue->BooleanValue(isolate);
-            }
-        }
+    auto count = args.Length();
+    if (count == 6) {
+        auto ctx = args[1].As<v8::BigInt>()->Int64Value();
+        auto webgl = canvas_native_webgl_create(
+                ctx,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible
+        );
+
+        auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
+                                                                    new WebGL2RenderingContext(
+                                                                            webgl,
+                                                                            WebGLRenderingVersion::V2));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
 
+    } else if (count ==
+               7) {
+        auto width = args[1]->NumberValue(context).ToChecked();
+        auto height = args[2]->NumberValue(context).ToChecked();
+        auto ctx = canvas_native_webgl_create_no_window(
+                (int32_t) width,
+                (int32_t) height,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible,
+                false
+        );
+        auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
+                                                                    new WebGL2RenderingContext(
+                                                                            ctx,
+                                                                            WebGLRenderingVersion::V2));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
 
-        if (version !=
-            "v2") {
-            args.GetReturnValue().SetNull();
-            return;
-        } else {
-            auto count = args.Length();
-            if (count == 6) {
-                auto ctx = args[1].As<v8::BigInt>()->Int64Value();
-//                auto density = args[2]->NumberValue(context).ToChecked();
-//                auto fontColor = args[3]->NumberValue(context).ToChecked();
-//                auto ppi = args[4]->NumberValue(context).ToChecked();
-//                auto direction = args[5]->NumberValue(context).ToChecked();
-
-                auto webgl = canvas_native_webgl_create(
-                        ctx,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible
-                );
-
-                auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
-                                                                            new WebGL2RenderingContext(
-                                                                                    webgl,
-                                                                                    WebGLRenderingVersion::V2));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
+    } else {
+        auto width = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto height = (int32_t) args[2]->NumberValue(context).ToChecked();
+        auto ctx = canvas_native_webgl_create_no_window(
+                width,
+                height,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible,
+                false
+        );
+
+        auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
+                                                                    new WebGL2RenderingContext(
+                                                                            ctx,
+                                                                            WebGLRenderingVersion::V2));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
+    }
+}
 
-            } else if (count ==
-                       7) {
-                auto width = args[1]->NumberValue(context).ToChecked();
-                auto height = args[2]->NumberValue(context).ToChecked();
-//                auto density = args[3]->NumberValue(context).ToChecked();
-//                auto fontColor = args[4]->NumberValue(context).ToChecked();
-//                auto ppi = args[5]->NumberValue(context).ToChecked();
-//                auto direction = args[6]->NumberValue(context).ToChecked();
-                auto ctx = canvas_native_webgl_create_no_window(
-                        (int32_t) width,
-                        (int32_t) height,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible,
-                        false
-                );
-                auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
-                                                                            new WebGL2RenderingContext(
-                                                                                    ctx,
-                                                                                    WebGLRenderingVersion::V2));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
+void
+CanvasJSIModule::CreateWebGPUContextWithPointer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto ptr = args[0]->ToBigInt(context).ToLocalChecked()->Int64Value();
 
-            } else {
-                auto width = (int32_t) args[1]->NumberValue(context).ToChecked();
-                auto height = (int32_t) args[2]->NumberValue(context).ToChecked();
-                auto ctx = canvas_native_webgl_create_no_window(
-                        width,
-                        height,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible,
-                        false
-                );
-
-                auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
-                                                                            new WebGL2RenderingContext(
-                                                                                    ctx,
-                                                                                    WebGLRenderingVersion::V2));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
-            }
-        }
-    }
+    auto wgpu = static_cast<CanvasGPUCanvasContext *>((void *) ptr);
 
-    args.GetReturnValue().SetNull();
+    auto ret = GPUCanvasContextImpl::NewInstance(isolate, new GPUCanvasContextImpl(
+            wgpu));
+    args.GetReturnValue().Set(ret);
 }