@nativescript/canvas 2.0.0-beta.0 → 2.0.0-beta.10

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

@@ -28,6 +28,10 @@
 class CanvasRenderingContext2DImpl : ObjectWrapperImpl {
 public:
 
+    static v8::CFunction fast_start_raf_;
+
+    static v8::CFunction fast_stop_raf_;
+
     static v8::CFunction fast_draw_point_;
 
     static v8::CFunction fast_arc_;
@@ -102,12 +106,16 @@ public:
 
     static v8::CFunction fast_fill_rect_;
 
+    static v8::CFunction fast_fill_oval_;
+
     static v8::CFunction fast_stroke_;
 
     static v8::CFunction fast_stroke_path_;
 
     static v8::CFunction fast_stroke_rect_;
 
+    static v8::CFunction fast_stroke_oval_;
+
     static v8::CFunction fast_rotate_;
 
     static v8::CFunction fast_reset_transform_;
@@ -118,9 +126,39 @@ public:
 
     static v8::CFunction fast_translate_;
 
+    static v8::CFunction fast_draw_atlas_;
+
 
     CanvasRenderingContext2DImpl(CanvasRenderingContext2D *context);
 
+    void StartRaf();
+
+    void StopRaf();
+
+    static void __StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __FastStartRaf(v8::Local<v8::Object> receiver_obj) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        ptr->StartRaf();
+
+    }
+
+    static void __StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __FastStopRaf(v8::Local<v8::Object> receiver_obj) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        ptr->StopRaf();
+
+    }
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static CanvasRenderingContext2DImpl *GetPointer(const v8::Local<v8::Object> &object);
@@ -163,6 +201,15 @@ public:
 
     static void __Resize(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+    static void SetContinuousRenderMode(v8::Local<v8::String> property,
+                                        v8::Local<v8::Value> value,
+                                        const v8::PropertyCallbackInfo<void> &info);
+
+    static void GetContinuousRenderMode(v8::Local<v8::String> property,
+                                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
     static void GetFilter(v8::Local<v8::String> property,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
@@ -489,18 +536,10 @@ public:
 
         if (GetNativeType(path_obj) == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
-            switch (rule) {
-                case 0:
-                case 1:
-                    canvas_native_context_clip(
-                            ptr->GetContext(), path->GetPath(), rule);
-                    break;
-                default:
-                    break;
-            }
+            canvas_native_context_clip(
+                    ptr->GetContext(), path->GetPath(), rule);
         }
 
-
     }
 
     static void ClosePath(const v8::FunctionCallbackInfo<v8::Value> &args);
@@ -536,6 +575,51 @@ public:
 
     static void DrawFocusIfNeeded(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+    static void DrawAtlas(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+/*
+    static void FastDrawAtlas(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Object> image_obj, v8::Local<v8::Array> xform, v8::Local<v8::Array> tex, v8::Local<v8::Array> xform) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto len = array->Length();
+        std::vector<float> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<float>::Build().GetId(), float>(
+                array, buf.data(), len);
+
+        if (copied) {
+
+        auto imageType = GetNativeType(image_obj);
+        switch (imageType) {
+            case NativeType::ImageAsset: {
+                auto asset = ImageAssetImpl::GetPointer(image_obj);
+
+            }
+                break;
+            case NativeType::ImageBitmap: {
+                auto asset = ImageBitmapImpl::GetPointer(image_obj);
+            }
+                break;
+            case NativeType::CanvasRenderingContext2D: {
+                auto context = CanvasRenderingContext2DImpl::GetPointer(image_obj);
+
+            }
+                break;
+            default:
+                break;
+        }
+
+
+        ptr->UpdateInvalidateState();
+    }
+        */
+
     static void DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
@@ -800,18 +884,10 @@ public:
         auto object = Path2D::GetPointer(path);
 
         if (object != nullptr) {
-            switch (rule) {
-                case 0:
-                case 1:
-                    canvas_native_context_fill_with_path(
-                            ptr->GetContext(),
-                            object->GetPath(),
-                            rule);
-                    break;
-                default:
-                    break;
-            }
-
+            canvas_native_context_fill_with_path(
+                    ptr->GetContext(),
+                    object->GetPath(),
+                    rule);
             ptr->UpdateInvalidateState();
         }
     }
@@ -837,16 +913,9 @@ public:
             return;
         }
 
-        switch (rule) {
-            case 0:
-            case 1:
-                canvas_native_context_fill(
-                        ptr->GetContext(), rule);
-                ptr->UpdateInvalidateState();
-                break;
-            default:
-                break;
-        }
+        canvas_native_context_fill(
+                ptr->GetContext(), rule);
+        ptr->UpdateInvalidateState();
     }
 
     static void FastFill(v8::Local<v8::Object> receiver_obj) {
@@ -882,6 +951,27 @@ public:
 
     static void FillText(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+    static void FillOval(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void FastFillOval(v8::Local<v8::Object> receiver_obj, double x, double y, double width,
+                             double height) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        canvas_native_context_fill_oval(
+                ptr->GetContext(),
+                static_cast<float>(x),
+                static_cast<float>(y),
+                static_cast<float>(width),
+                static_cast<float>(height)
+        );
+        ptr->UpdateInvalidateState();
+    }
+
     static void GetImageData(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void GetLineDash(const v8::FunctionCallbackInfo<v8::Value> &args);
@@ -907,18 +997,8 @@ public:
             return false;
         }
 
-        bool ret = false;
-        switch (rule) {
-            case 0:
-            case 1:
-                ret = canvas_native_context_is_point_in_path(
-                        ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule);
-                break;
-            default:
-                break;
-        }
-
-        return ret;
+        return canvas_native_context_is_point_in_path(
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule);
     }
 
     static bool
@@ -939,17 +1019,9 @@ public:
             auto path = Path2D::GetPointer(path_obj);
 
 
-            switch (rule) {
-                case 0:
-                case 1:
-                    ret = canvas_native_context_is_point_in_path_with_path(
-                            ptr->GetContext(),
-                            path->GetPath(), x, y, rule);
-                    break;
-                    break;
-                default:
-                    break;
-            }
+            ret = canvas_native_context_is_point_in_path_with_path(
+                    ptr->GetContext(),
+                    path->GetPath(), x, y, rule);
 
         }
         return ret;
@@ -1279,6 +1351,9 @@ public:
                 f);
     }
 
+
+    static void GetTransform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
     static void Stroke(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void FastStroke(v8::Local<v8::Object> receiver_obj) {
@@ -1322,6 +1397,27 @@ public:
 
     static void StrokeText(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+
+
+    static void StrokeOval(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    static void FastStrokeOval(v8::Local<v8::Object> receiver_obj, double x, double y, double width,
+                               double height) {
+        CanvasRenderingContext2DImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        canvas_native_context_stroke_oval(
+                ptr->GetContext(), static_cast<float>(x),
+                static_cast<float>(y),
+                static_cast<float>(width),
+                static_cast<float>(height));
+        ptr->UpdateInvalidateState();
+    }
+
+
     static void Transform(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
@@ -1382,4 +1478,6 @@ private:
 
     std::shared_ptr<RafImpl> raf_;
 
+    bool continuousRender_ = true;
+
 };

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

@@ -8,7 +8,7 @@
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class MatrixImpl: ObjectWrapperImpl {
+class MatrixImpl: public ObjectWrapperImpl {
 public:
     MatrixImpl(Matrix* matrix);
     ~MatrixImpl(){

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

@@ -51,9 +51,6 @@ v8::CFunction Path2D::fast_quadratic_curve_to_(v8::CFunction::Make(Path2D::FastQ
 
 v8::CFunction Path2D::fast_rect_(v8::CFunction::Make(Path2D::FastRect));
 
-//v8::CFunction Path2D::fast_round_rect_(v8::CFunction::Make(Path2D::FastRoundRect));
-
-
 v8::CFunction Path2D::fast_round_rect_(
         v8::CFunction::Make(Path2D::FastRoundRect));
 
@@ -65,6 +62,8 @@ const v8::CFunction fast_round_rect_overloads_[] = {
         Path2D::fast_round_rect_array_
 };
 
+v8::CFunction Path2D::fast_trim_(v8::CFunction::Make(Path2D::FastTrim));
+
 
 
 //v8::CFunction Path2D::fast_to_svg_(v8::CFunction::Make(Path2D::FastToSVG));
@@ -76,7 +75,7 @@ void Path2D::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto ret = args.This();
 
-    SetNativeType( ret, NativeType::Path2D);
+    SetNativeType(ret, NativeType::Path2D);
 
     if (count > 0) {
         if (value->IsString()) {
@@ -385,6 +384,21 @@ void Path2D::RoundRect(const v8::FunctionCallbackInfo<v8::Value> &args) {
     args.GetReturnValue().SetUndefined();
 }
 
+void Path2D::Trim(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    Path2D *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    canvas_native_path_trim(ptr->GetPath(),
+                            static_cast<float>(args[0]->NumberValue(context).ToChecked()),
+                            static_cast<float>(args[1]->NumberValue(context).ToChecked()));
+}
+
 void Path2D::__toSVG(const v8::FunctionCallbackInfo<v8::Value> &args) {
     Path2D *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
@@ -443,50 +457,7 @@ v8::Local<v8::FunctionTemplate> Path2D::GetCtor(v8::Isolate *isolate) {
     SetFastMethodWithOverLoads(isolate, tmpl, "roundRect", RoundRect,
                                fast_round_rect_overloads_, v8::Local<v8::Value>());
 
-    //    tmpl->Set(
-//            ConvertToV8String(isolate, "addPath"),
-//            v8::FunctionTemplate::New(isolate, &AddPath));
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "arc"),
-//            v8::FunctionTemplate::New(isolate, &Arc));
-
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "bezierCurveTo"),
-//            v8::FunctionTemplate::New(isolate, &BezierCurveTo));
-
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "closePath"),
-//            v8::FunctionTemplate::New(isolate, &ClosePath));
-
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "ellipse"),
-//            v8::FunctionTemplate::New(isolate, &Ellipse));
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "lineTo"),
-//            v8::FunctionTemplate::New(isolate, &LineTo));
-
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "moveTo"),
-//            v8::FunctionTemplate::New(isolate, &MoveTo));
-
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "quadraticCurveTo"),
-//            v8::FunctionTemplate::New(isolate, &QuadraticCurveTo));
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "rect"),
-//            v8::FunctionTemplate::New(isolate, &Rect));
-
-//    tmpl->Set(
-//            ConvertToV8String(isolate, "roundRect"),
-//            v8::FunctionTemplate::New(isolate, &RoundRect));
+    SetFastMethod(isolate, tmpl, "trim", Trim, &fast_trim_, v8::Local<v8::Value>());
 
     tmpl->Set(
             ConvertToV8String(isolate, "__toSVG"),

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

@@ -64,6 +64,8 @@ public:
     static v8::CFunction fast_round_rect_array_;
     // static v8::CFunction fast_to_svg_; // todo after v8 upgrade
 
+    static v8::CFunction fast_trim_;
+
 
     static void Arc(const v8::FunctionCallbackInfo<v8::Value> &args);
 
@@ -429,6 +431,23 @@ public:
 
     static void RoundRect(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void Trim(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void
+    FastTrim(v8::Local<v8::Object> receiver_obj, double start, double end) {
+
+        Path2D *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+        canvas_native_path_trim(
+                ptr->GetPath(),
+                static_cast<float>(start),
+                static_cast<float>(end)
+        );
+    }
+
     static void __toSVG(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 

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

@@ -6302,6 +6302,11 @@ WebGLRenderingContext::SetMethods(v8::Isolate *isolate, const v8::Local<v8::Obje
                   v8::Local<v8::Value>());
 
 
+
+    tmpl->SetAccessor(ConvertToV8String(isolate, "continuousRenderMode"), GetContinuousRenderMode,
+                      SetContinuousRenderMode);
+
+
     // todo
     tmpl->Set(ConvertToV8String(isolate, "__toDataURL"),
               v8::FunctionTemplate::New(isolate, &__ToDataURL));

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

@@ -1557,13 +1557,13 @@ public:
             return;
         }
 
-
-        DrawArraysImpl(
-                ptr,
+        canvas_native_webgl_draw_arrays(
                 mode,
                 first,
-                count
+                count,
+                ptr->GetState()
         );
+        ptr->UpdateInvalidateState();
     }
 
     static void DrawElements(const v8::FunctionCallbackInfo<v8::Value> &args);

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

@@ -7,8 +7,8 @@
 WebGLRenderingContextBase::WebGLRenderingContextBase(WebGLState* state,
                                                      WebGLRenderingVersion version)
 : state_(state), version_(version) {
-    
-    
+
+
     auto ctx_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(this));
     auto raf_callback = new OnRafCallback(
                                           ctx_ptr,
@@ -19,13 +19,44 @@ WebGLRenderingContextBase::WebGLRenderingContextBase(WebGLState* state,
                  std::make_shared<RafImpl>(
                                            raf_callback,
                                            raf_callback_ptr, raf));
-    
+
     auto _raf = this->GetRaf();
-    
+
     if (_raf != nullptr) {
         canvas_native_raf_start(_raf->GetRaf());
     }
-    
+
+}
+
+
+void WebGLRenderingContextBase::GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLRenderingContextBase *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(false);
+        return;
+    }
+    info.GetReturnValue().Set(ptr->continuousRender_);
+}
+
+void WebGLRenderingContextBase::SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           v8::Local<v8::Value> value,
+                                                           const v8::PropertyCallbackInfo<void> &info) {
+    WebGLRenderingContextBase *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = info.GetIsolate();
+    auto val = value->BooleanValue(isolate);
+    if (val == ptr->continuousRender_) {
+        return;
+    }
+    if (val) {
+        ptr->StartRaf();
+    } else {
+        ptr->StopRaf();
+    }
+    ptr->continuousRender_ = val;
 }
 
 
@@ -64,8 +95,7 @@ void WebGLRenderingContextBase::Flush() {
     auto state = this->GetInvalidateState() & (int) InvalidateState::InvalidateStatePending;
     if (state == (int) InvalidateState::InvalidateStatePending) {
         this->SetInvalidateState((int) InvalidateState::InvalidateStateInvalidating);
-        canvas_native_webgl_make_current(this->GetState());
-        canvas_native_webgl_swap_buffers(this->GetState());
+        canvas_native_webgl_make_current_and_swap_buffers(this->GetState());
         this->SetInvalidateState((int) InvalidateState::InvalidateStateNone);
     }
 }

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

@@ -32,6 +32,14 @@ public:
         return static_cast<WebGLRenderingContextBase *>(ptr);
     }
 
+
+    static void GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                            v8::Local<v8::Value> value,
+                                                            const v8::PropertyCallbackInfo<void> &info);
+
     ~WebGLRenderingContextBase();
 
     void UpdateInvalidateState();
@@ -66,5 +74,7 @@ private:
     int invalidateState_ = static_cast<int>(InvalidateState::InvalidateStateNone);
 
     std::shared_ptr<RafImpl> raf_;
+
+    bool continuousRender_ = true;
 };
 

package/src-native/ios/NativeScript.podspec

@@ -6,7 +6,7 @@ Pod::Spec.new do |s|
 
     s.authors      = "Ammar Ahmed"
     s.homepage     = "https://github.com/ammarahm-ed/nativescript-v8-module"
-    s.platforms    = { :ios => "12.4" }
+    s.platforms    = { :ios => "12.0" }
     s.source       = { :git => "https://github.com/ammarahm-ed/nativescript-v8-module.git", :tag => "v1.0.0" }
     s.cocoapods_version      = ">= 1.10.1"
     s.vendored_frameworks = "NativeScript.xcframework"