@nativescript/canvas 2.0.0-beta.1 → 2.0.0-beta.3

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_;
@@ -121,6 +125,34 @@ public:
 
     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 +195,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 +530,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);
@@ -800,18 +833,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 +862,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) {
@@ -907,18 +925,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 +947,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;
@@ -1385,4 +1385,6 @@ private:
 
     std::shared_ptr<RafImpl> raf_;
 
+    bool continuousRender_ = true;
+
 };

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/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"