@nativescript/canvas 2.0.0-webgpu.31 → 2.0.0-webgpu.34

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

@@ -232,19 +232,8 @@ void CanvasJSIModule::Create2DContext(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
     auto ptr = args[0].As<v8::BigInt>()->Int64Value();
-    auto width = (float) args[1]->NumberValue(context).ToChecked();
-    auto height = (float) args[2]->NumberValue(context).ToChecked();
-    auto density = (float) args[3]->NumberValue(context).ToChecked();
-    auto samples = (int) args[4]->NumberValue(context).ToChecked();
-    auto alpha = (bool) args[5]->BooleanValue(isolate);
-    auto font_color = (int) args[6]->NumberValue(context).ToChecked();
-    auto ppi = (float) args[7]->NumberValue(context).ToChecked();
-    auto direction = (int) args[8]->NumberValue(context).ToChecked();
-
-    auto context_2d = canvas_native_context_create_gl(width, height, density,
-                                                      ptr,
-                                                      samples, alpha,
-                                                      font_color, ppi, direction);
+
+    auto context_2d = static_cast<CanvasRenderingContext2D *>((void *)ptr);
 
     auto ret = CanvasRenderingContext2DImpl::NewInstance(isolate, new CanvasRenderingContext2DImpl(
             context_2d));
@@ -397,7 +386,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
                             callback->Call(context, context->Global(),
                                            2,
                                            args);  // ignore JS return value
-                            
+
                             delete asset_data;
 
                         } else {
@@ -610,7 +599,7 @@ void CanvasJSIModule::Create2DContextWithPointer(const v8::FunctionCallbackInfo<
 struct FileData {
     char *error_;
     U8Buffer* data;
-    
+
     ~FileData() {
         if (error_ != nullptr) {
             canvas_native_string_destroy(error_);
@@ -623,8 +612,8 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
     auto isolate = args.GetIsolate();
     auto file = ConvertFromV8String(isolate, args[0]);
     auto cbFunc = args[1].As<v8::Function>();
-    
-    
+
+
     auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
         if(data == nullptr){return;}
         auto async_data = static_cast<AsyncCallback *>(data);
@@ -638,10 +627,10 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
                                                                    isolate);
             v8::Local<v8::Context> context = callback->GetCreationContextChecked();
             v8::Context::Scope context_scope(context);
-            
+
             if (func->data != nullptr) {
                 auto file_data = static_cast<FileData*>(func->data);
-                
+
                 v8::Local<v8::Value> args[2];
 
                 if (done) {
@@ -657,7 +646,7 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
                                                                       if (deleter_data !=
                                                                           nullptr) {
                                                                           delete static_cast<FileData *>(deleter_data);
-                                                                          
+
                                                                       }
                                                                   },
                                                                   func->data);
@@ -698,13 +687,13 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
                 }
 
                 delete async_data;
-                
+
             }
         }
     });
-    
+
     callback->prepare();
-    
+
     std::thread thread(
             [callback, file]() {
                 bool done = false;
@@ -723,8 +712,8 @@ void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args)
             });
 
     thread.detach();
-    
-    
+
+
 
 }
 
@@ -745,20 +734,7 @@ void CanvasJSIModule::CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Valu
     auto count = args.Length();
     if (count == 6) {
         auto ctx = args[1].As<v8::BigInt>()->Int64Value();
-        auto webgl = canvas_native_webgl_create(
-                ctx,
-                options.version,
-                options.alpha,
-                options.antialias,
-                options.depth,
-                options.failIfMajorPerformanceCaveat,
-                options.powerPreference,
-                options.premultipliedAlpha,
-                options.preserveDrawingBuffer,
-                options.stencil,
-                options.desynchronized,
-                options.xrCompatible
-        );
+        auto webgl = static_cast<WebGLState*>((void *)ctx);
 
         auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
                                                                    new WebGLRenderingContext(
@@ -841,22 +817,8 @@ void CanvasJSIModule::CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Val
 
     auto count = args.Length();
     if (count == 6) {
-        auto ctx = args[1].As<v8::BigInt>()->Int64Value();
-        auto webgl = canvas_native_webgl_create(
-                ctx,
-                options.version,
-                options.alpha,
-                options.antialias,
-                options.depth,
-                options.failIfMajorPerformanceCaveat,
-                options.powerPreference,
-                options.premultipliedAlpha,
-                options.preserveDrawingBuffer,
-                options.stencil,
-                options.desynchronized,
-                options.xrCompatible
-        );
-
+        auto ctx = args[0].As<v8::BigInt>()->Int64Value();
+        auto webgl = static_cast<WebGLState*>((void *)ctx);
         auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
                                                                     new WebGL2RenderingContext(
                                                                             webgl,

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

@@ -1110,7 +1110,6 @@ void CanvasRenderingContext2DImpl::SetTextAlign(v8::Local<v8::String> property,
 void CanvasRenderingContext2DImpl::GetTextBaseline(v8::Local<v8::String> property,
                                                    const v8::PropertyCallbackInfo<v8::Value> &info) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(info.This());
-    auto isolate = info.GetIsolate();
     if (ptr == nullptr) {
         info.GetReturnValue().Set(0);
         return;
@@ -1963,7 +1962,6 @@ CanvasRenderingContext2DImpl::DrawAtlas(const v8::FunctionCallbackInfo<v8::Value
         return;
     }
 
-    auto count = args.Length();
     auto value = args[0];
 
     if (value->IsNullOrUndefined() || !value->IsObject()) {
@@ -2968,8 +2966,6 @@ void
 CanvasRenderingContext2DImpl::Stroke(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
 
-    auto isolate = args.GetIsolate();
-
     auto value = args[0];
     auto type = GetNativeType(value);
     if (type == NativeType::Path2D) {
@@ -3136,12 +3132,12 @@ CanvasRenderingContext2DImpl::~CanvasRenderingContext2DImpl() {
 }
 
 void CanvasRenderingContext2DImpl::UpdateInvalidateState() {
-    auto raf = this->GetRaf();
-    if (raf != nullptr) {
-        if (!canvas_native_raf_get_started(raf->GetRaf())) {
-            canvas_native_raf_start(raf->GetRaf());
-        }
-    }
+//    auto raf = this->GetRaf();
+//    if (raf != nullptr) {
+//        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+//            canvas_native_raf_start(raf->GetRaf());
+//        }
+//    }
 
     auto state = this->GetInvalidateState();
     this->SetInvalidateState((int) state | (int) InvalidateState::InvalidateStatePending);

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

@@ -82,11 +82,11 @@ void WebGLRenderingContextBase::StopRaf() {
 
 void WebGLRenderingContextBase::UpdateInvalidateState() {
     auto raf = this->GetRaf();
-    if (raf != nullptr) {
-        if (!canvas_native_raf_get_started(raf->GetRaf())) {
-            canvas_native_raf_start(raf->GetRaf());
-        }
-    }
+//    if (raf != nullptr) {
+//        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+//            canvas_native_raf_start(raf->GetRaf());
+//        }
+//    }
     auto state = this->GetInvalidateState();
     this->SetInvalidateState(state | (int) InvalidateState::InvalidateStatePending);
 }

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

@@ -1295,12 +1295,12 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
     auto options = optionsVal.As<v8::Object>();
 
     v8::Local<v8::Value> stencilValue;
-    options->Get(context, ConvertToV8String(isolate, "depthStencil")).ToLocal(
+    auto hasDepthStencil = options->Get(context, ConvertToV8String(isolate, "depthStencil")).ToLocal(
             &stencilValue);
 
     CanvasDepthStencilState *stencil = nullptr;
 
-    if (!stencilValue.IsEmpty() && stencilValue->IsObject()) {
+    if (hasDepthStencil && stencilValue->IsObject()) {
         auto stencilObj = stencilValue.As<v8::Object>();
         stencil = new CanvasDepthStencilState{};
         stencil->depth_bias = 0;
@@ -1491,14 +1491,14 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> fragmentValue;
-    options->Get(context, ConvertToV8String(isolate, "fragment")).ToLocal(
+    auto hasFragment = options->Get(context, ConvertToV8String(isolate, "fragment")).ToLocal(
             &fragmentValue);
 
     CanvasFragmentState *fragment = nullptr;
 
     std::vector<CanvasColorTargetState> targets;
 
-    if (!fragmentValue.IsEmpty() && fragmentValue->IsObject()) {
+    if (hasFragment && fragmentValue->IsObject()) {
         auto fragmentValueObj = fragmentValue.As<v8::Object>();
         fragment = new CanvasFragmentState{};
 
@@ -1532,9 +1532,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
             v8::Local<v8::Value> writeMaskVal;
 
-            state->Get(context, ConvertToV8String(isolate, "writeMask")).ToLocal(&writeMaskVal);
+            auto hasWriteMask = state->Get(context, ConvertToV8String(isolate, "writeMask")).ToLocal(&writeMaskVal);
 
-            if (!writeMaskVal.IsEmpty() && writeMaskVal->IsUint32()) {
+            if (hasWriteMask && writeMaskVal->IsUint32()) {
                 writeMask = writeMaskVal->Uint32Value(context).FromJust();
             }
 
@@ -1544,9 +1544,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
             v8::Local<v8::Value> blendVal;
 
-            state->Get(context, ConvertToV8String(isolate, "blend")).ToLocal(&blendVal);
+            auto hasBlend = state->Get(context, ConvertToV8String(isolate, "blend")).ToLocal(&blendVal);
 
-            if (!blendVal.IsEmpty() && blendVal->IsObject()) {
+            if (hasBlend && blendVal->IsObject()) {
                 auto blendObj = blendVal.As<v8::Object>();
                 auto alpha = blendObj->Get(context, ConvertToV8String(isolate,
                                                                       "alpha")).ToLocalChecked().As<v8::Object>();
@@ -1638,10 +1638,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         }
 
         v8::Local<v8::Value> constantsVal;
-        fragmentValueObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(
+        auto hasConstants = fragmentValueObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(
                 &constantsVal);
 
-        if (!constantsVal.IsEmpty() && constantsVal->IsMap()) {
+        if (hasConstants && constantsVal->IsMap()) {
             auto constants = constantsVal.As<v8::Map>();
             auto keyValues = constants->AsArray();
             auto length = keyValues->Length();
@@ -1675,11 +1675,11 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
         v8::Local<v8::Value> entryPoint;
-        fragmentValueObj->Get(context, ConvertToV8String(isolate, "entryPoint")).ToLocal(
+        auto hasEntryPoint = fragmentValueObj->Get(context, ConvertToV8String(isolate, "entryPoint")).ToLocal(
                 &entryPoint);
 
 
-        if (!entryPoint.IsEmpty() && entryPoint->IsString()) {
+        if (hasEntryPoint && entryPoint->IsString()) {
             auto ep = v8::String::Utf8Value(isolate, entryPoint);
             char *entry_point = (char *) malloc(ep.length());
             std::strcpy(entry_point, *ep);
@@ -1707,7 +1707,6 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
     auto label = GPULabel(isolate, labelVal);
 
-
     descriptor.label = *label;
 
 
@@ -1738,13 +1737,13 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> multisampleValue;
-    options->Get(context, ConvertToV8String(isolate, "multisample")).ToLocal(
+    auto hasMultisample = options->Get(context, ConvertToV8String(isolate, "multisample")).ToLocal(
             &multisampleValue);
 
 
     CanvasMultisampleState *multisample = nullptr;
 
-    if (!multisampleValue.IsEmpty() && multisampleValue->IsObject()) {
+    if (hasMultisample && multisampleValue->IsObject()) {
         auto multisampleObj = multisampleValue.As<v8::Object>();
         multisample = new CanvasMultisampleState{};
         multisample->alpha_to_coverage_enabled = false;
@@ -1755,25 +1754,25 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         v8::Local<v8::Value> count;
         v8::Local<v8::Value> mask;
 
-        multisampleObj->Get(context, ConvertToV8String(isolate, "alphaToCoverageEnabled")).
+        auto hasAlphaToCoverageEnabled = multisampleObj->Get(context, ConvertToV8String(isolate, "alphaToCoverageEnabled")).
                 ToLocal(&alphaToCoverageEnabled);
 
-        if (!alphaToCoverageEnabled.IsEmpty() && alphaToCoverageEnabled->IsBoolean()) {
+        if (hasAlphaToCoverageEnabled && alphaToCoverageEnabled->IsBoolean()) {
             multisample->alpha_to_coverage_enabled = alphaToCoverageEnabled->BooleanValue(
                     isolate);
         }
 
-        multisampleObj->Get(context, ConvertToV8String(isolate, "count")).
+        auto hasCount = multisampleObj->Get(context, ConvertToV8String(isolate, "count")).
                 ToLocal(&count);
 
-        if (!count.IsEmpty() && count->IsUint32()) {
+        if (hasCount && count->IsUint32()) {
             multisample->count = count.As<v8::Uint32>()->Value();
         }
 
-        multisampleObj->Get(context, ConvertToV8String(isolate, "mask")).
+        auto hasMask = multisampleObj->Get(context, ConvertToV8String(isolate, "mask")).
                 ToLocal(&mask);
 
-        if (!mask.IsEmpty() && mask->IsNumber()) {
+        if (hasMask && mask->IsNumber()) {
             // todo verify mask
             auto maskValue = mask.As<v8::Number>()->Value();
             multisample->mask = (uint64_t) maskValue;
@@ -1786,13 +1785,13 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> primitiveValue;
-    options->Get(context, ConvertToV8String(isolate, "primitive")).ToLocal(
+    auto hasPrimitive = options->Get(context, ConvertToV8String(isolate, "primitive")).ToLocal(
             &primitiveValue);
 
 
     CanvasPrimitiveState *primitive = nullptr;
 
-    if (!primitiveValue.IsEmpty() && primitiveValue->IsObject()) {
+    if (hasPrimitive && primitiveValue->IsObject()) {
         auto primitiveObj = primitiveValue.As<v8::Object>();
         primitive = new CanvasPrimitiveState{};
 
@@ -1968,7 +1967,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
 
     v8::Local<v8::Value> vertexValue;
-    options->Get(context, ConvertToV8String(isolate, "vertex")).ToLocal(
+   auto hasVertex = options->Get(context, ConvertToV8String(isolate, "vertex")).ToLocal(
             &vertexValue);
 
 
@@ -1978,7 +1977,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
     std::vector<std::vector<CanvasVertexAttribute>> attributes;
 
-    if (!vertexValue.IsEmpty() && vertexValue->IsObject()) {
+    if (hasVertex && vertexValue->IsObject()) {
         auto vertexObj = vertexValue.As<v8::Object>();
         vertex = new CanvasVertexState{};
 
@@ -1990,9 +1989,9 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         vertex->module = module->GetShaderModule();
 
         v8::Local<v8::Value> constantsVal;
-        vertexObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(&constantsVal);
+        auto hasConstants = vertexObj->Get(context, ConvertToV8String(isolate, "constants")).ToLocal(&constantsVal);
 
-        if (!constantsVal.IsEmpty() && constantsVal->IsMap()) {
+        if (hasConstants && constantsVal->IsMap()) {
             auto constants = constantsVal.As<v8::Map>();
             auto keyValues = constants->AsArray();
             auto len = keyValues->Length();
@@ -2027,10 +2026,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
         }
 
         v8::Local<v8::Value> buffersVal;
-        vertexObj->Get(context, ConvertToV8String(isolate, "buffers")).ToLocal(&buffersVal);
+        auto hasBuffers = vertexObj->Get(context, ConvertToV8String(isolate, "buffers")).ToLocal(&buffersVal);
 
         uint64_t stride = 0;
-        if (!buffersVal.IsEmpty() && buffersVal->IsArray()) {
+        if (hasBuffers && buffersVal->IsArray()) {
             auto buffers = buffersVal.As<v8::Array>();
             auto len = buffers->Length();
 
@@ -2039,10 +2038,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
                 v8::Local<v8::Value> arrayStride;
 
-                buffer->Get(context, ConvertToV8String(isolate, "arrayStride")).ToLocal(
+                auto hasArrayStride = buffer->Get(context, ConvertToV8String(isolate, "arrayStride")).ToLocal(
                         &arrayStride);
 
-                if (!arrayStride.IsEmpty() && arrayStride->IsNumber()) {
+                if (hasArrayStride && arrayStride->IsNumber()) {
                     stride = (uint64_t) arrayStride.As<v8::Number>()->Value();
                 }
 
@@ -2050,10 +2049,10 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
 
                 v8::Local<v8::Value> attributesValue;
 
-                buffer->Get(context, ConvertToV8String(isolate, "attributes")).ToLocal(
+                auto hasAttributes = buffer->Get(context, ConvertToV8String(isolate, "attributes")).ToLocal(
                         &attributesValue);
 
-                if (!attributesValue.IsEmpty() && attributesValue->IsArray()) {
+                if (hasAttributes && attributesValue->IsArray()) {
                     auto attributes_array = attributesValue.As<v8::Array>();
                     auto attributes_len = attributes_array->Length();
 
@@ -2144,6 +2143,7 @@ void GPUDeviceImpl::CreateRenderPipeline(const v8::FunctionCallbackInfo<v8::Valu
     }
 
 
+
     auto pipeline = canvas_native_webgpu_device_create_render_pipeline(ptr->GetGPUDevice(),
                                                                        &descriptor);
 

package/utils.d.ts

@@ -4,6 +4,6 @@ export declare class Utils {
     static _CHECKED_FOR_SUPPORT: boolean;
     static toJSArray(array: any): any[];
     static get IS_SUPPORTED_TYPED_ARRAYS_VERSION(): boolean;
-    static isTypedArray(value: any): value is Uint32Array | Uint8Array | Uint8ClampedArray | Int32Array | Float32Array | Int8Array | Uint16Array | Int16Array;
+    static isTypedArray(value: any): value is Uint32Array | Uint8Array | Uint8ClampedArray | Int8Array | Uint16Array | Int16Array | Int32Array | Float32Array;
 }
 export default function lazy<T>(action: () => T): () => T;