@nativescript/canvas 2.0.0-rc.10 → 2.0.0-rc.11

package/platforms/ios/src/cpp/OnRafCallback.cpp

@@ -5,21 +5,26 @@
 #include "OnRafCallback.h"
 #include "canvas2d/CanvasRenderingContext2DImpl.h"
 #include "webgl/WebGLRenderingContextBase.h"
+#include "webgpu/GPUCanvasContextImpl.h"
 
 OnRafCallback::OnRafCallback(intptr_t context, uint32_t version) : context_(context),
-                                                                   version_(version) {}
+version_(version) {}
 
 void OnRafCallback::OnFrame(int64_t ts) const {
-    if (this->version_ == 0) {
-        CanvasRenderingContext2DImpl::Flush(this->context_);
-    }
-
-    if (this->version_ == 1 || this->version_ == 2) {
-        WebGLRenderingContextBase::Flush(this->context_);
-    }
+	if (this->version_ == 0) {
+		CanvasRenderingContext2DImpl::Flush(this->context_);
+	}
+	
+	if (this->version_ == 1 || this->version_ == 2) {
+		WebGLRenderingContextBase::Flush(this->context_);
+	}
+	
+	if(this->version_ == 3){
+		GPUCanvasContextImpl::Flush(this->context_);
+	}
 }
 
 void OnRafCallbackOnFrame(intptr_t callback, int64_t ts) {
-    auto ptr = reinterpret_cast<OnRafCallback *>(reinterpret_cast<intptr_t *>(callback));
-    ptr->OnFrame(ts);
+	auto ptr = reinterpret_cast<OnRafCallback *>(reinterpret_cast<intptr_t *>(callback));
+	ptr->OnFrame(ts);
 }

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

@@ -11,6 +11,7 @@ class OnRafCallback {
     // 0 2d
     // 1 gl
     // 2 gl2
+		// 3 gpu
 public:
     OnRafCallback(intptr_t context, uint32_t version);
 

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

@@ -1147,11 +1147,8 @@ void CanvasRenderingContext2DImpl::GetGlobalCompositeOperation(v8::Local<v8::Str
         info.GetReturnValue().Set(0);
         return;
     }
-    auto operation = canvas_native_context_get_global_composition(ptr->GetContext());
-    info.GetReturnValue().Set(
-            ConvertToV8String(info.GetIsolate(), operation));
-
-    canvas_native_string_destroy((char *) operation);
+    auto operation = canvas_native_context_get_global_composition_int(ptr->GetContext());
+		info.GetReturnValue().Set(operation);
 }
 
 void CanvasRenderingContext2DImpl::SetGlobalCompositeOperation(v8::Local<v8::String> property,
@@ -1162,8 +1159,15 @@ void CanvasRenderingContext2DImpl::SetGlobalCompositeOperation(v8::Local<v8::Str
         return;
     }
     auto isolate = info.GetIsolate();
-    auto operation = ConvertFromV8String(isolate, value);
-    canvas_native_context_set_global_composition(ptr->GetContext(), operation.c_str());
+	
+	uint32_t operation = 0;
+	auto context = isolate->GetCurrentContext();
+	if (value->Uint32Value(context).To(&operation)) {
+		canvas_native_context_set_global_composition_int(ptr->GetContext(), operation);
+	}
+	
+//    auto operation = ConvertFromV8String(isolate, value);
+//    canvas_native_context_set_global_composition(ptr->GetContext(), operation.c_str());
 }
 
 
@@ -1220,10 +1224,33 @@ void CanvasRenderingContext2DImpl::SetFillStyle(v8::Local<v8::String> property,
     auto isolate = info.GetIsolate();
 
     if (value->IsString()) {
-        auto style = ConvertFromV8String(isolate, value);
-        canvas_native_paint_style_set_fill_color_with_c_string(ptr->GetContext(),
-                                                               style.c_str());
-    } else if (value->IsObject()) {
+//        auto style = ConvertFromV8String(isolate, value);
+			
+			auto val = value.As<v8::String>();
+			int len = val->Utf8Length(isolate) + 1;
+			char buffer [len];
+			val->WriteUtf8(isolate, buffer, len, nullptr, v8::String::WriteOptions::PRESERVE_ONE_BYTE_NULL);
+			
+		//	v8::String::Utf8Value result(isolate, value);
+
+//			const char *val = *result;
+
+//			if (buffer == nullptr) {
+//					return;
+//			}
+		
+			canvas_native_paint_style_set_fill_color_with_c_string(ptr->GetContext(), buffer);
+		}else if(value->IsStringObject()){
+			
+			auto val = value.As<v8::StringObject>()->ValueOf();
+			
+			int len = val->Utf8Length(isolate) + 1;
+			char buffer [len];
+			val->WriteUtf8(isolate, buffer, len, nullptr, v8::String::WriteOptions::PRESERVE_ONE_BYTE_NULL);
+			
+			canvas_native_paint_style_set_fill_color_with_c_string(ptr->GetContext(), buffer);
+			
+		} else if (value->IsObject()) {
 
         auto type = GetNativeType(value);
 
@@ -1300,10 +1327,27 @@ void CanvasRenderingContext2DImpl::SetStrokeStyle(v8::Local<v8::String> property
     auto isolate = info.GetIsolate();
 
     if (value->IsString()) {
-        auto style = ConvertFromV8String(isolate, value);
-        canvas_native_paint_style_set_stroke_color_with_c_string(ptr->GetContext(),
-                                                                 style.c_str());
-    } else if (value->IsObject()) {
+//        auto style = ConvertFromV8String(isolate, value);
+
+			auto val = value.As<v8::String>();
+			
+			int len = val->Utf8Length(isolate) + 1;
+			char buffer [len];
+			val->WriteUtf8(isolate, buffer, len, nullptr, v8::String::WriteOptions::PRESERVE_ONE_BYTE_NULL);
+			
+			
+			canvas_native_paint_style_set_stroke_color_with_c_string(ptr->GetContext(), buffer);
+			
+		}else if(value->IsStringObject()){
+			auto val = value.As<v8::StringObject>()->ValueOf();
+			
+			int len = val->Utf8Length(isolate) + 1;
+			char buffer [len];
+			val->WriteUtf8(isolate, buffer, len, nullptr, v8::String::WriteOptions::PRESERVE_ONE_BYTE_NULL);
+			
+			
+			canvas_native_paint_style_set_stroke_color_with_c_string(ptr->GetContext(), buffer);
+		} else if (value->IsObject()) {
 
         auto type = GetNativeType(value);
 

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

@@ -355,7 +355,7 @@ void Path2D::RoundRect(const v8::FunctionCallbackInfo<v8::Value> &args) {
                 auto array = radii.As<v8::Array>();
                 auto size = array->Length();
 
-                if (size > 1) {
+                if (size >= 1) {
                     std::vector<float> store;
                     store.reserve(size);
                     for (int i = 0;

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

@@ -209,11 +209,8 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
 
         v8::Local<v8::Value> requiredFeaturesValue;
 
-        options->Get(context, ConvertToV8String(isolate, "requiredFeatures")).ToLocal(
-                &requiredFeaturesValue);
-
-
-        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsArray()) {
+        if ( options->Get(context, ConvertToV8String(isolate, "requiredFeatures")).ToLocal(
+																																													 &requiredFeaturesValue) && requiredFeaturesValue->IsArray()) {
             v8::Local<v8::Array> requiredFeatures = requiredFeaturesValue.As<v8::Array>();
             auto len = requiredFeatures->Length();
             for (int i = 0; i < len; i++) {
@@ -229,10 +226,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
 
         v8::Local<v8::Value> limitsValue;
 
-        options->Get(context, ConvertToV8String(isolate, "requiredLimits")).ToLocal(
-                &limitsValue);
 
-        if (!limitsValue.IsEmpty() && limitsValue->IsObject()) {
+        if (options->Get(context, ConvertToV8String(isolate, "requiredLimits")).ToLocal(
+																																												&limitsValue) && limitsValue->IsObject()) {
             auto limits_ptr = GPUSupportedLimitsImpl::GetPointer(limitsValue.As<v8::Object>());
             if (limits_ptr != nullptr) {
                 limits = limits_ptr->GetLimits();