@nativescript/canvas 2.0.0-webgpu.2 → 2.0.0-webgpu.4

package/platforms/ios/src/NSOperationQueueWrapper.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <functional>
 class NSOperationQueueWrapper {
 public:

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

@@ -0,0 +1,206 @@
+//
+// Created by Osei Fortune on 05/08/2024.
+//
+
+#pragma once
+
+#include "Common.h"
+
+#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 AsyncCallback {
+
+    struct Inner {
+        NSOperationQueueWrapper* current_queue = nullptr;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Function> callback_;
+        CompleteCallback completeCallback_;
+        CompleteCallback completeCallbackWrapper_;
+        bool isPrepared_ = false;
+        void* data = nullptr;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Function>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+
+            this->completeCallbackWrapper_ = [](bool success, void *data){
+                if(data != nullptr){
+                    auto* callback = static_cast<AsyncCallback*>(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, AsyncCallback* callback){
+            completeCallbackWrapper_(complete, callback);
+        }
+
+        ~Inner() {
+            callback_.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 AsyncCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+
+    AsyncCallback(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+                  CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {
+    }
+
+
+};
+#endif
+
+#ifdef __ANDROID__
+
+struct AsyncCallback {
+
+    struct Inner {
+        int fd_[2];
+        ALooper *looper_;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Function> callback_;
+        CompleteCallback completeCallback_;
+        bool isPrepared_ = false;
+        void* data;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Function>(
+                                                           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();
+        }
+    };
+
+    std::shared_ptr<Inner> inner_;
+
+    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 AsyncCallback(this->inner_);
+        ALooper_addFd(looper,
+                      fd,
+                      ALOOPER_POLL_CALLBACK,
+                      ALOOPER_EVENT_INPUT,
+                      [](int fd, int events,
+                         void *data) {
+                          auto cb = static_cast<AsyncCallback *>(data);
+                          bool done = false;
+                          read(fd, &done,
+                               sizeof(bool));
+                          cb->inner_->completeCallback_(done, data);
+                          return 0;
+                      }, (void *) data);
+
+        ALooper_wake(looper);
+    }
+
+    void execute(bool complete) const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete);
+    }
+
+
+    explicit AsyncCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+
+    AsyncCallback(v8::Isolate *isolate, v8::Local<v8::Function> callback,
+                  CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {
+    }
+
+
+};
+
+#endif

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

@@ -927,7 +927,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
         }
     }
 
-    auto type = GetNativeType(image);
+    auto type = ObjectWrapperImpl::GetNativeType(image);
 
     if (len == 1 || len == 2) {
         if (len == 2) {

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

@@ -8,6 +8,8 @@
 #include "Common.h"
 #include "OneByteStringResource.h"
 #include "v8-fast-api-calls.h"
+#include "AsyncCallback.h"
+#include "PromiseCallback.h"
 //#ifdef __APPLE__
 //#ifdef __OBJC__
 //#include <Foundation/Foundation.h>
@@ -17,19 +19,6 @@
 //#endif
 //#endif
 
-
-struct AsyncCallback {
-    v8::Isolate *isolate;
-    v8::Global<v8::Function> callback;
-    void *data;
-};
-
-struct PromiseCallback {
-    v8::Isolate *isolate;
-    v8::Global<v8::Promise::Resolver> callback;
-    void *data;
-};
-
 static const char *LOG_TAG = "JS";
 static int m_maxLogcatObjectSize = 4096;
 
@@ -81,89 +70,6 @@ static void LogToConsole(const std::string &message) {
 #endif
 }
 
-enum class NativeMask {
-    Type = 1
-};
-
-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
-};
-
 inline static v8::Local<v8::String>
 ConvertToV8OneByteString(v8::Isolate *isolate, std::string string) {
     auto value = new OneByteStringResource(std::move(string));
@@ -207,74 +113,6 @@ ConvertFromV8String(v8::Isolate *isolate, const v8::Local<v8::Value> &value) {
 }
 
 
-static void SetPrivateValue(v8::Isolate *isolate, const v8::Local<v8::Object> &obj,
-                            const v8::Local<v8::String> &propName,
-                            const v8::Local<v8::Value> &value) {
-    v8::Local<v8::Context> context;
-    auto succcess = obj->GetCreationContext().ToLocal(&context);
-    v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, propName);
-    obj->SetPrivate(context, privateKey, value);
-}
-
-static v8::Local<v8::Value>
-GetPrivateValue(v8::Isolate *isolate, const v8::Local<v8::Object> &obj,
-                const v8::Local<v8::String> &propName) {
-    v8::Local<v8::Context> context;
-    auto succcess = obj->GetCreationContext().ToLocal(&context);
-    v8::Local<v8::Private> privateKey = v8::Private::ForApi(isolate, propName);
-
-    v8::Maybe<bool> hasPrivate = obj->HasPrivate(context, privateKey);
-
-    if (!hasPrivate.FromMaybe(false)) {
-        return {};
-    }
-
-    v8::Local<v8::Value> result;
-
-    succcess = obj->GetPrivate(context, privateKey).ToLocal(&result);
-
-    return result;
-}
-
-static void SetNativeType(const v8::Local<v8::Object> &obj, NativeType type) {
-    auto value = (int32_t) type;
-    obj->SetAlignedPointerInInternalField(1, new int32_t(value));
-}
-
-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(1);
-
-        if (info != nullptr) {
-            auto value = *static_cast<int32_t *>(info);
-            auto ret = value;
-            if (ret >= (int) NativeType::CanvasGradient &&
-                ret <= (int) NativeType::GPURenderBundle) {
-                return (NativeType) ret;
-            }
-        }
-    }
-
-    return NativeType::None;
-}
-
-
-//template<class T>
-//static inline void Finalizer(const v8::WeakCallbackInfo<T> &data) {
-//    auto *pThis = data.GetParameter();
-//    pThis->weakHandle_.Reset();
-//    delete pThis;
-//}
-
-//static inline void BindFinalizer(v8::Isolate *isolate, v8::Global<v8::Object> &weakHandle, const v8::Local<v8::Object> &object) {
-//    v8::HandleScope scopedHandle(isolate);
-//    weakHandle.Reset(isolate, object);
-//    weakHandle.SetWeak(this, Finalizer, v8::WeakCallbackType::kParameter);
-//}
-
-
-
 static void SetFastMethod(v8::Isolate *isolate,
                           v8::Local<v8::Template> that,
                           const char *name,

package/platforms/ios/src/cpp/ImageAssetImpl.cpp

@@ -122,12 +122,12 @@ void ImageAssetImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto ret = args.This();
 
-    SetNativeType(ret, NativeType::ImageAsset);
-
     auto image_asset = canvas_native_image_asset_create();
 
     auto object = new ImageAssetImpl(image_asset);
 
+    SetNativeType(object, NativeType::ImageAsset);
+
     ret->SetAlignedPointerInInternalField(0, object);
 
     object->BindFinalizer(isolate, ret);

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

@@ -30,11 +30,12 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = ImageBitmapImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::ImageBitmap);
 
         auto ptr = asset->Value();
         auto impl = static_cast<ObjectWrapperImpl *>(ptr);
 
+        SetNativeType(impl, NativeType::ImageBitmap);
+
 
         object->SetAlignedPointerInInternalField(0, ptr);
 

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_;