@nativescript/canvas 2.0.0-webgpu.1 → 2.0.0-webgpu.3

package/platforms/ios/src/cpp/NativeType.h

@@ -0,0 +1,87 @@
+//
+// Created by Osei Fortune on 06/08/2024.
+//
+
+#ifndef CANVAS_ANDROID_NATIVETYPE_H
+#define CANVAS_ANDROID_NATIVETYPE_H
+
+enum class NativeType {
+    None,
+    CanvasGradient,
+    CanvasPattern,
+    ImageData,
+    ImageAsset,
+    CanvasRenderingContext2D,
+    WebGLRenderingContextBase,
+    Path2D,
+    Matrix,
+    ImageBitmap,
+    TextMetrics,
+
+    WebGLQuery,
+    WebGLProgram,
+    WebGLShader,
+    WebGLBuffer,
+    WebGLFramebuffer,
+    WebGLRenderbuffer,
+    WebGLTexture,
+    WebGLActiveInfo,
+    OES_fbo_render_mipmap,
+    EXT_blend_minmax,
+    EXT_color_buffer_half_float,
+    EXT_disjoint_timer_query,
+    EXT_sRGB,
+    EXT_shader_texture_lod,
+    EXT_texture_filter_anisotropic,
+    OES_element_index_uint,
+    OES_standard_derivatives,
+    OES_texture_float,
+    OES_texture_float_linear,
+    OES_texture_half_float_linear,
+    OES_texture_half_float,
+    WEBGL_color_buffer_float,
+    OES_vertex_array_object,
+    WebGLVertexArrayObject,
+    WEBGL_compressed_texture_atc,
+    WEBGL_compressed_texture_etc1,
+    WEBGL_compressed_texture_s3tc,
+    WEBGL_compressed_texture_s3tc_srgb,
+    WEBGL_compressed_texture_etc,
+    WEBGL_compressed_texture_pvrtc,
+    WEBGL_lose_context,
+    ANGLE_instanced_arrays,
+    WEBGL_depth_texture,
+    WEBGL_draw_buffers,
+    WebGLShaderPrecisionFormat,
+    WebGLUniformLocation,
+    WebGLSampler,
+    WebGLTransformFeedback,
+    WebGLSync,
+
+    GPUAdapter,
+    GPUSupportedLimits,
+    GPUDevice,
+    GPUQueue,
+    GPUBuffer,
+    GPUInstance,
+    GPUCanvasContext,
+    GPUTexture,
+    GPUAdapterInfo,
+    GPUCommandEncoder,
+    GPUComputePass,
+    GPUQuerySet,
+    GPUShaderModule,
+    GPUPipelineLayout,
+    GPURenderPipeline,
+    GPUBindGroupLayout,
+    GPUTextureView,
+    GPURenderPassEncoder,
+    GPUCommandBuffer,
+    GPUBindGroup,
+    GPUComputePipeline,
+    GPUSampler,
+    GPURenderBundleEncoder,
+    GPURenderBundle
+};
+
+#endif //CANVAS_ANDROID_NATIVETYPE_H

package/platforms/ios/src/cpp/ObjectWrapperImpl.h

@@ -9,9 +9,11 @@
 #define ObjectWrapperImpl_h
 
 #include "Common.h"
+#include "NativeType.h"
 
 class ObjectWrapperImpl {
 public:
+    NativeType type_ = NativeType::None;
 
     static void Finalizer(const v8::WeakCallbackInfo<ObjectWrapperImpl> &data) {
         auto *pThis = data.GetParameter();
@@ -25,6 +27,54 @@ public:
         weakHandle_.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
     }
 
+
+    /*
+    static void SetNativeType(const v8::Local<v8::Object> &obj, NativeType type) {
+        if (!obj.IsEmpty() && !obj->IsNullOrUndefined() && obj->IsObject() &&
+            obj.As<v8::Object>()->InternalFieldCount() > 1) {
+            auto wrapper = obj.As<v8::Object>()->GetAlignedPointerFromInternalField(0);
+            if (wrapper != nullptr) {
+                ((ObjectWrapperImpl *) wrapper)->type_ = type;
+            }
+        }
+    }
+     */
+
+    inline static NativeType GetNativeType(const v8::Local<v8::Value> &obj) {
+        if (!obj.IsEmpty() && !obj->IsNullOrUndefined() && obj->IsObject() &&
+            obj.As<v8::Object>()->InternalFieldCount() > 1) {
+            auto info = obj.As<v8::Object>()->GetAlignedPointerFromInternalField(0);
+
+            if (info != nullptr) {
+                auto value = static_cast<ObjectWrapperImpl *>(info);
+                return value->type_;
+            }
+        }
+
+        return NativeType::None;
+    }
+
+    static void SetNativeType(ObjectWrapperImpl *obj, NativeType type) {
+        if (obj != nullptr) {
+            obj->type_ = type;
+        }
+    }
+
+    static NativeType GetNativeType(const ObjectWrapperImpl *obj) {
+        if (obj != nullptr) {
+            return obj->type_;
+        }
+        return NativeType::None;
+    }
+
+    static void SetNativeType(ObjectWrapperImpl &obj, NativeType type) {
+        obj.type_ = type;
+    }
+
+    static NativeType GetNativeType(const ObjectWrapperImpl &obj) {
+        return obj.type_;
+    }
+
 private:
     v8::Global<v8::Object> weakHandle_;
 

package/platforms/ios/src/cpp/OneByteStringResource.cpp

@@ -27,11 +27,11 @@ OneByteStringResource::OneByteStringResource(std::string string) : stdString_(st
 
 OneByteStringResource::~OneByteStringResource() {
     if (usingBuffer_) {
-        canvas_native_u8_buffer_destroy(buffer_);
+        canvas_native_u8_buffer_release(buffer_);
         this->string_ = nullptr;
         this->length_ = 0;
     }else if(usingCow_){
-        canvas_native_ccow_destroy(cow_);
+        canvas_native_ccow_release(cow_);
         this->string_ = nullptr;
         this->length_ = 0;
     }else if(usingString){

package/platforms/ios/src/cpp/PromiseCallback.h

@@ -0,0 +1,198 @@
+//
+// Created by Osei Fortune on 05/08/2024.
+//
+
+#pragma once
+
+#include "Common.h"
+#include <thread>
+
+#ifdef __ANDROID__
+
+#include <android/looper.h>
+#include <cassert>
+
+#endif
+
+#ifdef __APPLE__
+#include "NSOperationQueueWrapper.h"
+#endif
+
+
+#include <unistd.h>
+#include <fcntl.h>
+
+typedef void(*CompleteCallback)(bool success, void *data);
+
+#ifdef __APPLE__
+struct PromiseCallback {
+    struct Inner {
+        NSOperationQueueWrapper* current_queue = nullptr;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Promise::Resolver> callback_;
+        v8::Persistent<v8::Value> error_;
+        CompleteCallback completeCallback_;
+        CompleteCallback completeCallbackWrapper_;
+        bool isPrepared_ = false;
+        void* data;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Promise::Resolver>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+            this->completeCallbackWrapper_ = [](bool success, void *data){
+                if(data != nullptr){
+                    auto* callback = static_cast<PromiseCallback*>(data);
+                    auto inner = callback->inner_.get();
+                    if(inner == nullptr || inner->current_queue != nullptr){
+                        return;
+                    }
+
+                    inner->current_queue->addOperation([success, data, inner, callback](){
+                        inner->completeCallback_(success, data);
+                     //   delete callback;
+                    });
+                }
+            };
+        }
+
+        void prepare(){
+            current_queue = new NSOperationQueueWrapper(true);
+            isPrepared_ = true;
+        }
+
+        void execute(bool complete, PromiseCallback* callback){
+           completeCallbackWrapper_(complete, callback);
+        }
+
+        ~Inner(){
+            callback_.Reset();
+            error_.Reset();
+        }
+    };
+
+    std::shared_ptr<Inner> inner_;
+
+    void prepare(){
+       auto inner = this->inner_.get();
+       if(inner == nullptr){return;}
+        inner->prepare();
+    }
+
+        void execute(bool complete) {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete, this);
+    }
+
+    explicit PromiseCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+    PromiseCallback(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+                    CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {}
+};
+#endif
+
+#ifdef __ANDROID__
+
+struct PromiseCallback {
+    struct Inner {
+        int fd_[2];
+        ALooper *looper_ = nullptr;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Promise::Resolver> callback_;
+        void *data = nullptr;
+        CompleteCallback completeCallback_;
+        bool isPrepared_ = false;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Promise::Resolver>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+        }
+
+        void prepare() {
+            // release previous looper
+            if (isPrepared_) {
+                ALooper_removeFd(looper_, fd_[0]);
+                close(fd_[0]);
+                fd_[0] = -1;
+                fd_[1] = -1;
+                ALooper_release(looper_);
+            }
+
+            auto res = pipe(fd_);
+            assert(res != -1);
+            res = fcntl(fd_[1], F_SETFL, O_NONBLOCK);
+            assert(res != -1);
+            looper_ = ALooper_prepare(0);
+            ALooper_acquire(looper_);
+
+            isPrepared_ = true;
+        }
+
+        void execute(bool complete) const {
+            if (!isPrepared_) { return; }
+            write(fd_[1],
+                  &complete,
+                  sizeof(bool));
+        }
+
+
+        ~Inner() {
+            if (!isPrepared_) {
+                return;
+            }
+            ALooper_removeFd(looper_, fd_[0]);
+            close(fd_[0]);
+            ALooper_release(looper_);
+            callback_.Reset();
+        }
+    };
+
+    void prepare() const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->prepare();
+        auto looper = inner->looper_;
+        auto fd = inner->fd_[0];
+        auto data = new PromiseCallback(this->inner_);
+        ALooper_addFd(looper,
+                      fd,
+                      ALOOPER_POLL_CALLBACK,
+                      ALOOPER_EVENT_INPUT,
+                      [](int fd, int events,
+                         void *data) {
+                          auto cb = static_cast<PromiseCallback *>(data);
+                          bool done = false;
+                          read(fd, &done,
+                               sizeof(bool));
+                          cb->inner_->completeCallback_(done, data);
+                          return 0;
+                      }, (void *) data);
+
+        ALooper_wake(looper);
+        inner->isPrepared_ = true;
+    }
+
+    void execute(bool complete) const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete);
+    }
+
+    std::shared_ptr<Inner> inner_;
+
+    explicit PromiseCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+    PromiseCallback(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+                    CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {}
+
+};
+
+#endif

package/platforms/ios/src/cpp/RafImpl.h

@@ -12,9 +12,9 @@
 class RafImpl {
 public:
     RafImpl(OnRafCallback *rafCallback, intptr_t callback, Raf* raf);
-    
+
     ~RafImpl(){
-        canvas_native_raf_destroy(this->GetRaf());
+        canvas_native_raf_release(this->GetRaf());
         this->raf_ = nullptr;
         delete rafCallback_;
     }

package/platforms/ios/src/cpp/TextDecoderImpl.cpp

@@ -57,12 +57,6 @@ v8::Local<v8::FunctionTemplate> TextDecoderImpl::GetCtor(v8::Isolate *isolate) {
     return ctorTmpl;
 }
 
-void MyWeakCallback(const v8::WeakCallbackInfo<TextDecoderImpl>& info) {
-    TextDecoderImpl* obj = info.GetParameter();
-    // Perform cleanup or any necessary actions when the object is no longer reachable
-    delete obj;
-}
-
 void TextDecoderImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto count = args.Length();
     auto value = args[0];

package/platforms/ios/src/cpp/TextDecoderImpl.h

@@ -10,11 +10,11 @@
 
 class TextDecoderImpl: ObjectWrapperImpl {
 public:
-  
-    TextDecoderImpl(TextDecoder *decoder);
+
+    explicit TextDecoderImpl(TextDecoder *decoder);
 
     ~TextDecoderImpl() {
-        canvas_native_text_decoder_destroy(this->GetTextDecoder());
+        canvas_native_text_decoder_release(this->GetTextDecoder());
         this->decoder_ = nullptr;
     }
 

package/platforms/ios/src/cpp/TextEncoderImpl.cpp

@@ -122,7 +122,7 @@ void TextEncoderImpl::Encode(const v8::FunctionCallbackInfo<v8::Value> &args) {
                                                   [](void *data, size_t length,
                                                      void *deleter_data) {
                                                       if (deleter_data != nullptr) {
-                                                          canvas_native_u8_buffer_destroy((U8Buffer *)deleter_data);
+                                                          canvas_native_u8_buffer_release((U8Buffer *)deleter_data);
                                                       }
                                                   },
                                                   encoded);

package/platforms/ios/src/cpp/TextEncoderImpl.h

@@ -11,14 +11,14 @@
 class TextEncoderImpl: ObjectWrapperImpl {
 
 public:
-    TextEncoderImpl(TextEncoder* encoder);
+    explicit TextEncoderImpl(TextEncoder* encoder);
     ~TextEncoderImpl() {
-        canvas_native_text_encoder_destroy(this->GetTextEncoder());
+        canvas_native_text_encoder_release(this->GetTextEncoder());
         this->encoder_ = nullptr;
     }
 
     TextEncoder* GetTextEncoder();
-    
+
     static void Init(const v8::Local<v8::Object>& canvasModule, v8::Isolate *isolate);
 
     static TextEncoderImpl *GetPointer(v8::Local<v8::Object> object);

package/platforms/ios/src/cpp/canvas2d/CanvasGradient.h

@@ -3,21 +3,22 @@
 //
 
 #pragma once
+
 #include <vector>
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class CanvasGradient: ObjectWrapperImpl {
+class CanvasGradient : ObjectWrapperImpl {
 public:
-    CanvasGradient(PaintStyle*style);
+    explicit CanvasGradient(PaintStyle *style);
 
-    ~CanvasGradient(){
-        canvas_native_paint_style_destroy(this->GetPaintStyle());
+    ~CanvasGradient() {
+        canvas_native_paint_style_release(this->GetPaintStyle());
         this->style_ = nullptr;
     }
 
-    PaintStyle * GetPaintStyle();
+    PaintStyle *GetPaintStyle();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -30,7 +31,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = CanvasGradient::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::CanvasGradient);
+        SetNativeType(gradient, NativeType::CanvasGradient);
         object->SetAlignedPointerInInternalField(0, gradient);
         gradient->BindFinalizer(isolate, object);
         return scope.Escape(object);
@@ -39,6 +40,6 @@ public:
     static void AddColorStop(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    PaintStyle* style_;
+    PaintStyle *style_;
 };
 

package/platforms/ios/src/cpp/canvas2d/CanvasPattern.cpp

@@ -17,7 +17,7 @@ void CanvasPattern::Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasPattern"), func);
+    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasPattern"), func).FromJust();
 }
 
 v8::CFunction CanvasPattern::fast_set_transform_(

package/platforms/ios/src/cpp/canvas2d/CanvasPattern.h

@@ -10,10 +10,10 @@
 
 class CanvasPattern : ObjectWrapperImpl {
 public:
-    CanvasPattern(PaintStyle *style);
+    explicit CanvasPattern(PaintStyle *style);
 
     ~CanvasPattern() {
-        canvas_native_paint_style_destroy(this->GetPaintStyle());
+        canvas_native_paint_style_release(this->GetPaintStyle());
         this->style_ = nullptr;
     }
 
@@ -30,7 +30,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = CanvasPattern::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::CanvasPattern);
+        SetNativeType(pattern, NativeType::CanvasPattern);
         object->SetAlignedPointerInInternalField(0, pattern);
         pattern->BindFinalizer(isolate, object);
         return scope.Escape(object);