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

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

@@ -33,7 +33,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUAdapterImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUAdapter);
+        SetNativeType(adapter, NativeType::GPUAdapter);
         object->SetAlignedPointerInInternalField(0, adapter);
         adapter->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -21,7 +21,7 @@ void GPUAdapterInfoImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *i
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUAdapterInfo"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUAdapterInfo"), func).FromJust();
 }
 
 GPUAdapterInfoImpl *GPUAdapterInfoImpl::GetPointer(const v8::Local<v8::Object> &object) {

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

@@ -30,7 +30,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUAdapterInfoImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUAdapterInfo);
+        SetNativeType(info, NativeType::GPUAdapterInfo);
         object->SetAlignedPointerInInternalField(0, info);
         info->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -22,7 +22,7 @@ void GPUBindGroupImpl::Init(v8::Local <v8::Object> canvasModule, v8::Isolate *is
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroup"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroup"), func).FromJust();
 }
 
 GPUBindGroupImpl *GPUBindGroupImpl::GetPointer(const v8::Local <v8::Object> &object) {

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

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

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

@@ -22,7 +22,7 @@ void GPUBindGroupLayoutImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolat
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroupLayout"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUBindGroupLayout"), func).FromJust();
 }
 
 GPUBindGroupLayoutImpl *GPUBindGroupLayoutImpl::GetPointer(const v8::Local<v8::Object> &object) {

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

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

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) {
@@ -154,42 +154,56 @@ 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 {
+                        char* error = static_cast<char*>(func->data);
+                        callback->Reject(context,
+                                         v8::Exception::Error(
+                                                 ConvertToV8String(
+                                                         isolate,
+                                                         error)));
+                        canvas_native_string_destroy(
+                                error);
+                        func->data = nullptr;
+                    }
+                    delete static_cast<PromiseCallback *>(data);
+                }
+            }
     };
+    callback->prepare();
+
+
     canvas_native_webgpu_buffer_map_async(ptr->GetGPUBuffer(), (GPUMapMode) mode, offset, size,
                                           [](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 = error;
                                                       }
-                                                      delete static_cast<PromiseCallback *>(data);
+                                                      async_data->execute(true);
                                                   }
                                               }
                                           }, callback);

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

@@ -24,14 +24,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);
     }
 

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

@@ -22,7 +22,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) {

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

@@ -31,7 +31,7 @@ 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);

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

@@ -232,7 +232,6 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
     if (!descVal->IsNullOrUndefined() && descVal->IsObject()) {
         auto desc = descVal.As<v8::Object>();
 
-
         v8::Local<v8::Value> labelVal;
         desc->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
 
@@ -265,10 +264,10 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                                                             "view")).ToLocal(&viewVal);
 
             const CanvasGPUTextureView *view = nullptr;
-         
+
             auto viewPtr = GPUTextureViewImpl::GetPointer(viewVal.As<v8::Object>());
             view = viewPtr->GetTextureView();
-            
+
             const CanvasGPUTextureView *resolve_target = nullptr;
 
             v8::Local<v8::Value> resolve_target_val;
@@ -288,8 +287,8 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
             CanvasStoreOp store = CanvasStoreOp::CanvasStoreOpStore;
             v8::Local<v8::Value> loadVal;
 
-            if(colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                               "loadOp")).ToLocal(&loadVal)){
+            if (colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                                "loadOp")).ToLocal(&loadVal)) {
                 if (loadVal->IsUint32()) {
                     load = (CanvasLoadOp) loadVal->Uint32Value(
                             context).ToChecked();
@@ -302,11 +301,11 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     }
                 }
             }
-    
-         
+
+
             v8::Local<v8::Value> storeVal;
-            if(colorAttachment->Get(context, ConvertToV8String(isolate,
-                                                               "storeOp")).ToLocal(&storeVal)){
+            if (colorAttachment->Get(context, ConvertToV8String(isolate,
+                                                                "storeOp")).ToLocal(&storeVal)) {
                 if (storeVal->IsUint32()) {
                     store = (CanvasStoreOp) storeVal->Uint32Value(
                             context).ToChecked();
@@ -381,20 +380,20 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &depthLoadOp);
 
             depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                CanvasOptionalLoadOpNone
+                    CanvasOptionalLoadOpNone
             };
 
             if (!depthLoadOp.IsEmpty() && depthLoadOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, depthLoadOp);
                 if (value == "load") {
                     depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpLoad
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpLoad
                     };
                 } else if (value == "clear") {
                     depthStencilAttachment->depth_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpClear
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpClear
                     };
                 }
             }
@@ -406,20 +405,20 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &depthStoreOp);
 
             depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                CanvasOptionalStoreOpNone
+                    CanvasOptionalStoreOpNone
             };
 
             if (!depthStoreOp.IsEmpty() && depthStoreOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, depthStoreOp);
                 if (value == "store") {
                     depthStencilAttachment->depth_store_op = depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpStore
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpStore
                     };
                 } else if (value == "discard") {
                     depthStencilAttachment->depth_store_op = depthStencilAttachment->depth_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpDiscard
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpDiscard
                     };
                 }
             }
@@ -455,20 +454,20 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &stencilLoadOp);
 
             depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                CanvasOptionalLoadOpNone
+                    CanvasOptionalLoadOpNone
             };
 
             if (!stencilLoadOp.IsEmpty() && stencilLoadOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, stencilLoadOp);
                 if (value == "load") {
                     depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpLoad
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpLoad
                     };
                 } else if (value == "clear") {
                     depthStencilAttachment->stencil_load_op = CanvasOptionalLoadOp{
-                        CanvasOptionalLoadOpSome,
-                        CanvasLoadOpClear
+                            CanvasOptionalLoadOpSome,
+                            CanvasLoadOpClear
                     };
                 }
             }
@@ -480,20 +479,20 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
                     &stencilStoreOp);
 
             depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                CanvasOptionalStoreOpNone
+                    CanvasOptionalStoreOpNone
             };
 
             if (!stencilStoreOp.IsEmpty() && stencilStoreOp->IsString()) {
                 auto value = ConvertFromV8String(isolate, stencilStoreOp);
                 if (value == "store") {
                     depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpStore
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpStore
                     };
                 } else if (value == "discard") {
                     depthStencilAttachment->stencil_store_op = CanvasOptionalStoreOp{
-                        CanvasOptionalStoreOpSome,
-                        CanvasStoreOpDiscard
+                            CanvasOptionalStoreOpSome,
+                            CanvasStoreOpDiscard
                     };
                 }
             }
@@ -518,7 +517,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
         desc->Get(context, ConvertToV8String(isolate, "occlusionQuerySet")).ToLocal(
                 &occlusionQuerySetVal);
 
-        
+
         if (GetNativeType(occlusionQuerySetVal) == NativeType::GPUQuerySet) {
             auto occlusionQuerySet = GPUQuerySetImpl::GetPointer(
                     occlusionQuerySetVal.As<v8::Object>());
@@ -585,6 +584,7 @@ void GPUCommandEncoderImpl::BeginRenderPass(const v8::FunctionCallbackInfo<v8::V
 
         if (depthStencilAttachment != nullptr) {
             delete depthStencilAttachment;
+            depthStencilAttachment = nullptr;
         }
 
 
@@ -1099,7 +1099,6 @@ void GPUCommandEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &ar
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
     auto descVal = args[0];
     std::string label;
     bool didSet = false;

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

@@ -29,7 +29,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUCommandEncoderImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUCommandEncoder);
+        SetNativeType(encoder, NativeType::GPUCommandEncoder);
         object->SetAlignedPointerInInternalField(0, encoder);
         encoder->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -26,7 +26,7 @@ void GPUComputePassEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Iso
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUComputePassEncoder"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUComputePassEncoder"), func).FromJust();
 }
 
 GPUComputePassEncoderImpl *

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

@@ -30,7 +30,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = GPUComputePassEncoderImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::GPUComputePass);
+        SetNativeType(pass, NativeType::GPUComputePass);
         object->SetAlignedPointerInInternalField(0, pass);
         pass->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -24,7 +24,7 @@ void GPUComputePipelineImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolat
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "GPUComputePipeline"), func).FromJust();;
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPUComputePipeline"), func).FromJust();
 }
 
 GPUComputePipelineImpl *GPUComputePipelineImpl::GetPointer(const v8::Local<v8::Object> &object) {

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

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