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

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

@@ -0,0 +1,379 @@
+//
+// Created by Osei Fortune on 20/06/2024.
+//
+
+#include "GPUCanvasContextImpl.h"
+#include "Caches.h"
+#include "GPUAdapterImpl.h"
+#include "GPUUtils.h"
+#include "GPUQueueImpl.h"
+
+GPUCanvasContextImpl::GPUCanvasContextImpl(const CanvasGPUCanvasContext *context) : context_(
+        context) {}
+
+const CanvasGPUCanvasContext *GPUCanvasContextImpl::GetContext() {
+    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();
+}
+
+GPUCanvasContextImpl *GPUCanvasContextImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    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);
+
+
+    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));
+
+    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());
+
+}
+
+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:,"));
+    }
+
+
+}
+
+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();
+}
+
+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());
+        }
+    }
+
+}
+
+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);
+}

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

@@ -0,0 +1,57 @@
+//
+// Created by Osei Fortune on 20/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUCANVASCONTEXTIMPL_H
+#define CANVAS_ANDROID_GPUCANVASCONTEXTIMPL_H
+
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+#include "GPUDeviceImpl.h"
+#include "GPUTextureImpl.h"
+
+class GPUCanvasContextImpl : ObjectWrapperImpl {
+public:
+    explicit GPUCanvasContextImpl(const CanvasGPUCanvasContext *context);
+
+    ~GPUCanvasContextImpl() {
+        canvas_native_webgpu_context_release(this->context_);
+    }
+
+    const CanvasGPUCanvasContext *GetContext();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static void __ToDataURL(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static GPUCanvasContextImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUCanvasContextImpl *ctx) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUCanvasContextImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(ctx, NativeType::GPUCanvasContext);
+        object->SetAlignedPointerInInternalField(0, ctx);
+        ctx->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void Configure(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UnConfigure(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetCurrentTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PresentSurface(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetCapabilities(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+private:
+    const CanvasGPUCanvasContext *context_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUCANVASCONTEXTIMPL_H

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

@@ -0,0 +1,81 @@
+//
+// Created by Osei Fortune on 01/07/2024.
+//
+
+#include "GPUCommandBufferImpl.h"
+#include "Caches.h"
+
+GPUCommandBufferImpl::GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer)
+        : commandBuffer_(
+        commandBuffer) {}
+
+const CanvasGPUCommandBuffer *GPUCommandBufferImpl::GetGPUCommandBuffer() {
+    return this->commandBuffer_;
+}
+
+
+void GPUCommandBufferImpl::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, "GPUCommandBuffer"), func).FromJust();
+}
+
+GPUCommandBufferImpl *GPUCommandBufferImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUCommandBufferImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUCommandBufferImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUCommandBufferTmpl.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, "GPUCommandBuffer"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
+
+    cache->GPUCommandBufferTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void
+GPUCommandBufferImpl::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_buffer_get_label(ptr->commandBuffer_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}

package/platforms/ios/src/cpp/webgpu/GPUCommandBufferImpl.h

@@ -0,0 +1,48 @@
+//
+// Created by Osei Fortune on 01/07/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUCOMMANDBUFFERIMPL_H
+#define CANVAS_ANDROID_GPUCOMMANDBUFFERIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUCommandBufferImpl : ObjectWrapperImpl {
+public:
+    explicit GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer);
+
+    ~GPUCommandBufferImpl() {
+        canvas_native_webgpu_command_buffer_release(this->commandBuffer_);
+    }
+
+    const CanvasGPUCommandBuffer *GetGPUCommandBuffer();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUCommandBufferImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, GPUCommandBufferImpl *commandBuffer) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUCommandBufferImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(commandBuffer, NativeType::GPUCommandBuffer);
+        object->SetAlignedPointerInInternalField(0, commandBuffer);
+        commandBuffer->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+private:
+    const CanvasGPUCommandBuffer *commandBuffer_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUCOMMANDBUFFERIMPL_H