@nativescript/canvas 2.0.0-webgpu.11 → 2.0.0-webgpu.13

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

@@ -19,11 +19,11 @@
 class ImageAssetImpl : ObjectWrapperImpl {
 public:
 
-    explicit ImageAssetImpl(ImageAsset *asset);
+    explicit ImageAssetImpl(const ImageAsset *asset);
 
     ~ImageAssetImpl();
 
-    ImageAsset *GetImageAsset();
+    const ImageAsset *GetImageAsset();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -67,5 +67,5 @@ public:
 
 
 private:
-    ImageAsset *asset_;
+    const ImageAsset *asset_;
 };

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

@@ -5,10 +5,10 @@
 #include "ImageBitmapImpl.h"
 #include "Caches.h"
 
-ImageBitmapImpl::ImageBitmapImpl(ImageAsset* asset)
+ImageBitmapImpl::ImageBitmapImpl(const ImageAsset *asset)
         : bitmap_(asset) {}
 
-ImageBitmapImpl::~ImageBitmapImpl(){
+ImageBitmapImpl::~ImageBitmapImpl() {
     canvas_native_image_asset_release(bitmap_);
     this->bitmap_ = nullptr;
 }
@@ -56,6 +56,9 @@ v8::Local<v8::FunctionTemplate> ImageBitmapImpl::GetCtor(v8::Isolate *isolate) {
     tmpl->Set(
             ConvertToV8String(isolate, "close"), v8::FunctionTemplate::New(isolate, Close));
 
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "__addr"),
+            GetAddr);
 
     cache->ImageBitmapTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -93,6 +96,8 @@ void ImageBitmapImpl::Close(const v8::FunctionCallbackInfo<v8::Value> &args) {
         return;
     }
 
+    canvas_native_image_asset_close(ptr->GetImageAsset());
+
     ptr->closed_ = true;
 }
 
@@ -184,6 +189,20 @@ ImageBitmapImpl::HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value>
     return ret;
 }
 
-ImageAsset* ImageBitmapImpl::GetImageAsset() {
+
+void
+ImageBitmapImpl::GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto ret = std::to_string(canvas_native_image_asset_get_addr(ptr->GetImageAsset()));
+        info.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
+const ImageAsset *ImageBitmapImpl::GetImageAsset() {
     return this->bitmap_;
 }

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

@@ -21,7 +21,7 @@ struct Options {
 
 class ImageBitmapImpl : public ObjectWrapperImpl {
 public:
-    explicit ImageBitmapImpl(ImageAsset *asset);
+    explicit ImageBitmapImpl(const ImageAsset *asset);
 
     ~ImageBitmapImpl();
 
@@ -46,7 +46,7 @@ public:
 
     static Options HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value> &options);
 
-    ImageAsset *GetImageAsset();
+    const ImageAsset *GetImageAsset();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -60,9 +60,12 @@ public:
     static void GetHeight(v8::Local<v8::String> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
+    static void GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void Close(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    ImageAsset *bitmap_;
+    const ImageAsset *bitmap_;
     bool closed_ = false;
 };

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

@@ -163,7 +163,7 @@ struct PromiseCallback {
         auto data = new PromiseCallback(this->inner_);
         ALooper_addFd(looper,
                       fd,
-                      ALOOPER_POLL_CALLBACK,
+                      0,
                       ALOOPER_EVENT_INPUT,
                       [](int fd, int events,
                          void *data) {
@@ -175,7 +175,6 @@ struct PromiseCallback {
                           return 0;
                       }, (void *) data);
 
-        ALooper_wake(looper);
         inner->isPrepared_ = true;
     }
 

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

@@ -636,7 +636,7 @@ public:
     static void DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
-    DrawImageDxDyAssetImpl(CanvasRenderingContext2DImpl *ptr, ImageAsset *asset, double dx,
+    DrawImageDxDyAssetImpl(CanvasRenderingContext2DImpl *ptr, const ImageAsset *asset, double dx,
                            double dy) {
         if (asset != nullptr) {
             canvas_native_context_draw_image_dx_dy_asset(
@@ -690,7 +690,7 @@ public:
         }
     }
 
-    static void DrawImageDxDyDwDhAssetImpl(CanvasRenderingContext2DImpl *ptr, ImageAsset *asset,
+    static void DrawImageDxDyDwDhAssetImpl(CanvasRenderingContext2DImpl *ptr, const ImageAsset *asset,
                                            double dx, double dy, double dw, double dh) {
 
 
@@ -783,7 +783,7 @@ public:
 
     static void
     DrawImageAssetImpl(CanvasRenderingContext2DImpl *ptr,
-                       ImageAsset *asset, double sx,
+                       const ImageAsset *asset, double sx,
                        double sy, double sw, double sh, double dx, double dy, double dw,
                        double dh) {
 

package/platforms/ios/src/cpp/webgl/WebGLRenderingContext.cpp

@@ -4350,8 +4350,113 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
                     ptr->GetState()
             );
             return;
-        }
+        } else {
+            auto objectType = GetNativeType(value);
+
+            switch (objectType) {
+                case NativeType::ImageAsset: {
+                    auto image_asset = ImageAssetImpl::GetPointer(value.As<v8::Object>());
+
+                    if (image_asset !=
+                        nullptr) {
+
+                        canvas_native_webgl2_tex_image2d_image_asset(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_asset->GetImageAsset(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::ImageBitmap: {
+                    auto image_bitmap = ImageBitmapImpl::GetPointer(value.As<v8::Object>());
+
+                    if (image_bitmap !=
+                        nullptr) {
+                        canvas_native_webgl2_tex_image2d_image_asset(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_bitmap->GetImageAsset(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::CanvasRenderingContext2D: {
+                    auto canvas_2d = CanvasRenderingContext2DImpl::GetPointer(
+                            value.As<v8::Object>());
+
+                    if (canvas_2d != nullptr) {
+                        canvas_native_webgl2_tex_image2d_canvas2d(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                canvas_2d->GetContext(),
+                                ptr->GetState()
+                        );
+                    }
+
+                    return;
+                }
+                case NativeType::WebGLRenderingContextBase: {
+                    auto gl = WebGLRenderingContext::GetPointer(value.As<v8::Object>());
+
+                    if (gl != nullptr) {
+                        canvas_native_webgl2_tex_image2d_webgl(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                gl->GetState(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::ImageData: {
+                    auto image_data = ImageDataImpl::GetPointer(value.As<v8::Object>());
+                    if (image_data != nullptr) {
+                        canvas_native_webgl2_tex_image2d_image_data(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_data->GetImageData(),
+                                ptr->GetState()
+                        );
+                    }
 
+                }
+                default:
+                    break;
+            }
+        }
     }
 }
 

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

@@ -4,7 +4,7 @@
 
 #include "GPUAdapterImpl.h"
 #include "Caches.h"
-
+#include "GPULabel.h"
 GPUAdapterImpl::GPUAdapterImpl(const CanvasGPUAdapter *adapter) : adapter_(adapter) {}
 
 const CanvasGPUAdapter *GPUAdapterImpl::GetGPUAdapter() {
@@ -192,7 +192,7 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
 
     auto func = cb.As<v8::Function>();
 
-    std::string label;
+    GPULabel label;
 
     std::vector<std::string> required_features_buf;
 
@@ -203,10 +203,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         v8::Local<v8::Value> labelValue;
         options->Get(context, ConvertToV8String(isolate, "label")).ToLocal(
                 &labelValue);
+        
+        label = GPULabel(isolate, labelValue);
 
-        if (!labelValue.IsEmpty() && labelValue->IsString()) {
-            label = ConvertFromV8String(isolate, labelValue);
-        }
 
         v8::Local<v8::Value> requiredFeaturesValue;
 
@@ -299,6 +298,8 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                             callback->Call(context, context->Global(),
                                            1,
                                            args);  // ignore JS return value
+                            
+                            
                         } else {
 
                             auto impl = new GPUDeviceImpl(requestData->device_);
@@ -339,7 +340,7 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
     callback->prepare();
 
     canvas_native_webgpu_adapter_request_device(ptr->GetGPUAdapter(),
-                                                label.empty() ? nullptr : label.c_str(),
+                                                *label,
                                                 required_features_data,
                                                 required_features_data_length,
                                                 limits,