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

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

@@ -21,7 +21,7 @@ void GPUBufferImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolat
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBuffer"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBuffer"), func).FromJust();
 }
 
 GPUBufferImpl *GPUBufferImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -75,6 +75,11 @@ v8::Local<v8::FunctionTemplate> GPUBufferImpl::GetCtor(v8::Isolate *isolate) {
             ConvertToV8String(isolate, "getMappedRange"),
             v8::FunctionTemplate::New(isolate, &GetMappedRange));
 
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
 
     cache->GPUBufferTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -127,12 +132,17 @@ void GPUBufferImpl::UnMap(const v8::FunctionCallbackInfo<v8::Value> &args) {
     canvas_native_webgpu_buffer_unmap(ptr->GetGPUBuffer());
 }
 
+struct MapAsyncData {
+    enum CanvasGPUErrorType type;
+    char* error;
+};
 
 void GPUBufferImpl::MapAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
     GPUBufferImpl *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
     }
+
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
     auto mode = args[0]->Int32Value(context).ToChecked();
@@ -154,42 +164,59 @@ void GPUBufferImpl::MapAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto resolver = v8::Promise::Resolver::New(isolate->GetCurrentContext()).ToLocalChecked();
     args.GetReturnValue().Set(resolver->GetPromise());
 
-    v8::Global<v8::Promise::Resolver> promise(isolate, resolver);
     auto callback = new PromiseCallback{
             isolate,
-            std::move(promise)
+            resolver,
+            [](bool done, void *data){
+                auto async_data = static_cast<PromiseCallback *>(data);
+                auto func = async_data->inner_.get();
+                if (func != nullptr && func->isolate_ != nullptr) {
+                    v8::Isolate *isolate = func->isolate_;
+                    v8::Locker locker(isolate);
+                    v8::Isolate::Scope isolate_scope(
+                            isolate);
+                    v8::HandleScope handle_scope(
+                            isolate);
+                    v8::Local<v8::Promise::Resolver> callback = func->callback_.Get(
+                            isolate);
+                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                    v8::Context::Scope context_scope(
+                            context);
+
+
+                    if (func->data == nullptr) {
+                        callback->Resolve(context, v8::Undefined(isolate));
+                    } else {
+                        auto errorData = static_cast<MapAsyncData*>(func->data);
+                        callback->Reject(context,
+                                         v8::Exception::Error(
+                                                 ConvertToV8String(
+                                                         isolate,
+                                                         errorData->error)));
+                        canvas_native_string_destroy(
+                                errorData->error);
+                        delete errorData;
+                        func->data = nullptr;
+                    }
+                }
+                delete static_cast<PromiseCallback *>(data);
+            }
     };
-    canvas_native_webgpu_buffer_map_async(ptr->GetGPUBuffer(), (GPUMapMode) mode, offset, size,
-                                          [](char *error, void *data) {
+    callback->prepare();
+
+
+    canvas_native_webgpu_buffer_map_async(ptr->GetGPUBuffer(), mode == 1 ? GPUMapMode::GPUMapModeRead : GPUMapMode::GPUMapModeWrite, offset, size,
+                                          [](enum CanvasGPUErrorType type, char *error, void *data) {
                                               if (data != nullptr) {
-                                                  auto func = static_cast<PromiseCallback *>(data);
-                                                  if (func->isolate != nullptr) {
-                                                      v8::Isolate *isolate = func->isolate;
-                                                      v8::Locker locker(isolate);
-                                                      v8::Isolate::Scope isolate_scope(
-                                                              isolate);
-                                                      v8::HandleScope handle_scope(
-                                                              isolate);
-                                                      v8::Local<v8::Promise::Resolver> callback = func->callback.Get(
-                                                              isolate);
-                                                      v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                                      v8::Context::Scope context_scope(
-                                                              context);
-
-                                                      auto ret = v8::Object::New(
-                                                              isolate);
-                                                      if (error == nullptr) {
-                                                          callback->Resolve(context, ret);
-                                                      } else {
-                                                          callback->Reject(context,
-                                                                           v8::Exception::Error(
-                                                                                   ConvertToV8String(
-                                                                                           isolate,
-                                                                                           error)));
-                                                          canvas_native_string_destroy(
-                                                                  error);
+                                                  auto async_data = static_cast<PromiseCallback *>(data);
+                                                  auto inner = async_data->inner_.get();
+                                                  if (inner != nullptr) {
+                                                      if(error != nullptr){
+                                                          inner->data = new MapAsyncData {
+                                                              type, error
+                                                          };
                                                       }
-                                                      delete static_cast<PromiseCallback *>(data);
+                                                      async_data->execute(true);
                                                   }
                                               }
                                           }, callback);
@@ -227,3 +254,24 @@ void GPUBufferImpl::GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &ar
         args.GetReturnValue().Set(ab);
     }
 }
+
+
+void
+GPUBufferImpl::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_buffer_get_label(ptr->buffer_);
+        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/GPUBufferImpl.h

@@ -8,6 +8,7 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
+
 class GPUBufferImpl : ObjectWrapperImpl {
 public:
     explicit GPUBufferImpl(const CanvasGPUBuffer *buffer);
@@ -24,14 +25,14 @@ public:
 
     static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUBufferImpl *adapter) {
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPUBufferImpl *buffer) {
         auto context = isolate->GetCurrentContext();
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUBufferImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUBuffer);
-        object->SetAlignedPointerInInternalField(0, adapter);
-        adapter->BindFinalizer(isolate, object);
+        SetNativeType(buffer, NativeType::GPUBuffer);
+        object->SetAlignedPointerInInternalField(0, buffer);
+        buffer->BindFinalizer(isolate, object);
         return scope.Escape(object);
     }
 
@@ -50,6 +51,9 @@ public:
 
     static void GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
 
 private:
     const CanvasGPUBuffer *buffer_;

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

@@ -224,9 +224,14 @@ void GPUCanvasContextImpl::GetCurrentTexture(const v8::FunctionCallbackInfo<v8::
     auto texture = canvas_native_webgpu_context_get_current_texture(ctx);
 
     if (texture != nullptr) {
-        auto textureImpl = new GPUTextureImpl(texture);
-        auto ret = GPUTextureImpl::NewInstance(isolate, textureImpl);
-        args.GetReturnValue().Set(ret);
+        if(canvas_native_webgpu_texture_get_status(texture) == 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;
     }
 
@@ -270,7 +275,7 @@ void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Va
             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));
+                formats->Set(context, i, ConvertToV8String(isolate, format)).FromJust();
                 canvas_native_string_destroy(format);
             }
 
@@ -280,7 +285,7 @@ void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Va
 
             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));
+                present_modes->Set(context, i, ConvertToV8String(isolate, mode)).FromJust();
                 canvas_native_string_destroy(mode);
             }
 
@@ -290,15 +295,15 @@ void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Va
 
             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));
+                alpha_modes->Set(context, i, ConvertToV8String(isolate, mode)).FromJust();
                 canvas_native_string_destroy(mode);
             }
 
-            ret->Set(context, ConvertToV8String(isolate, "format"), formats);
-            ret->Set(context, ConvertToV8String(isolate, "presentModes"), present_modes);
-            ret->Set(context, ConvertToV8String(isolate, "alphaModes"), alpha_modes);
+            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));
+                     v8::Uint32::NewFromUnsigned(isolate, cap->usages)).FromJust();
 
             canvas_native_webgpu_struct_surface_capabilities_release(cap);
 
@@ -309,9 +314,9 @@ void GPUCanvasContextImpl::GetCapabilities(const v8::FunctionCallbackInfo<v8::Va
 
     }
 
-    ret->Set(context, ConvertToV8String(isolate, "format"), v8::Array::New(isolate));
-    ret->Set(context, ConvertToV8String(isolate, "presentModes"), v8::Array::New(isolate));
-    ret->Set(context, ConvertToV8String(isolate, "alphaModes"), v8::Array::New(isolate));
-    ret->Set(context, ConvertToV8String(isolate, "usages"), v8::Uint32::New(isolate, 0));
+    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

@@ -31,7 +31,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUCanvasContextImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUCanvasContext);
+        SetNativeType(ctx, NativeType::GPUCanvasContext);
         object->SetAlignedPointerInInternalField(0, ctx);
         ctx->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -5,7 +5,8 @@
 #include "GPUCommandBufferImpl.h"
 #include "Caches.h"
 
-GPUCommandBufferImpl::GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer) : commandBuffer_(
+GPUCommandBufferImpl::GPUCommandBufferImpl(const CanvasGPUCommandBuffer *commandBuffer)
+        : commandBuffer_(
         commandBuffer) {}
 
 const CanvasGPUCommandBuffer *GPUCommandBufferImpl::GetGPUCommandBuffer() {
@@ -22,7 +23,7 @@ void GPUCommandBufferImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUCommandBuffer"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUCommandBuffer"), func).FromJust();
 }
 
 GPUCommandBufferImpl *GPUCommandBufferImpl::GetPointer(const v8::Local<v8::Object> &object) {
@@ -47,8 +48,34 @@ v8::Local<v8::FunctionTemplate> GPUCommandBufferImpl::GetCtor(v8::Isolate *isola
     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

@@ -31,12 +31,15 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUCommandBufferImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUCommandBuffer);
+        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_;
 };