@nativescript/canvas 2.0.0-beta.2 → 2.0.0-beta.20

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

@@ -5,11 +5,21 @@
 #include "CanvasRenderingContext2DImpl.h"
 #include "Caches.h"
 #include "OneByteStringResource.h"
+#include "WebGLRenderingContextBase.h"
 
+v8::CFunction CanvasRenderingContext2DImpl::fast_start_raf_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::__FastStartRaf));
+
+v8::CFunction CanvasRenderingContext2DImpl::fast_stop_raf_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::__FastStopRaf));
 
 v8::CFunction CanvasRenderingContext2DImpl::fast_draw_point_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastDrawPoint));
 
+//v8::CFunction CanvasRenderingContext2DImpl::fast_draw_atlas_(
+//        v8::CFunction::Make(CanvasRenderingContext2DImpl::FastDrawAtlas));
+
+
 v8::CFunction CanvasRenderingContext2DImpl::fast_ellipse_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastEllipse));
 
@@ -81,13 +91,19 @@ v8::CFunction CanvasRenderingContext2DImpl::fast_clear_rect_(
 v8::CFunction CanvasRenderingContext2DImpl::fast_fill_rect_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastFillRect));
 
+v8::CFunction CanvasRenderingContext2DImpl::fast_fill_oval_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::FastFillOval));
+
+
 v8::CFunction CanvasRenderingContext2DImpl::fast_stroke_rect_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastStrokeRect));
 
+v8::CFunction CanvasRenderingContext2DImpl::fast_stroke_oval_(
+        v8::CFunction::Make(CanvasRenderingContext2DImpl::FastStrokeOval));
+
 v8::CFunction CanvasRenderingContext2DImpl::fast_rotate_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastRotate));
 
-
 v8::CFunction CanvasRenderingContext2DImpl::fast_fill_(
         v8::CFunction::Make(CanvasRenderingContext2DImpl::FastFill));
 
@@ -239,7 +255,7 @@ void CanvasRenderingContext2DImpl::Init(v8::Local<v8::Object> canvasModule, v8::
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasRenderingContext2D"), func);
+    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasRenderingContext2D"), func).FromJust();
 }
 
 CanvasRenderingContext2DImpl *
@@ -251,6 +267,27 @@ CanvasRenderingContext2DImpl::GetPointer(const v8::Local<v8::Object> &object) {
     return static_cast<CanvasRenderingContext2DImpl *>(ptr);
 }
 
+
+void CanvasRenderingContext2DImpl::StartRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_start(raf->GetRaf());
+        }
+    }
+}
+
+
+void CanvasRenderingContext2DImpl::StopRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_stop(raf->GetRaf());
+        }
+    }
+}
+
+
 v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->CanvasRenderingContext2DTmpl.get();
@@ -264,6 +301,13 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(2);
 
+
+    SetFastMethod(isolate, tmpl, "__startRaf", __StartRaf, &fast_start_raf_,
+                  v8::Local<v8::Value>());
+
+    SetFastMethod(isolate, tmpl, "__stopRaf", __StopRaf, &fast_stop_raf_,
+                  v8::Local<v8::Value>());
+
     SetFastMethod(isolate, tmpl, "drawPoint", DrawPoint, &fast_draw_point_, v8::Local<v8::Value>());
 
     tmpl->Set(ConvertToV8String(isolate, "drawPoints"),
@@ -278,6 +322,9 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
               v8::FunctionTemplate::New(isolate, __GetPointer));
     tmpl->Set(ConvertToV8String(isolate, "__resize"), v8::FunctionTemplate::New(isolate, __Resize));
 
+    tmpl->SetAccessor(ConvertToV8String(isolate, "continuousRenderMode"), GetContinuousRenderMode,
+                      SetContinuousRenderMode);
+
     tmpl->SetAccessor(ConvertToV8String(isolate, "filter"), GetFilter, SetFilter);
     tmpl->SetAccessor(ConvertToV8String(isolate, "font"), GetFont, SetFont);
     tmpl->SetAccessor(ConvertToV8String(isolate, "letterSpacing"), GetLetterSpacing,
@@ -319,24 +366,19 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
 
     SetFastMethod(isolate, tmpl, "beginPath", BeginPath, &fast_begin_path_, v8::Local<v8::Value>());
 
-
     SetFastMethod(isolate, tmpl, "bezierCurveTo", BezierCurveTo, &fast_bezier_curve_to_,
                   v8::Local<v8::Value>());
 
-
     tmpl->Set(ConvertToV8String(isolate, "clearHitRegions"),
               v8::FunctionTemplate::New(isolate, &ClearHitRegions));
 
-
     SetFastMethod(isolate, tmpl, "clearRect", ClearRect, &fast_clear_rect_, v8::Local<v8::Value>());
 
-
     SetFastMethodWithOverLoads(isolate, tmpl, "clip", Clip, fast_clip_overloads_,
                                v8::Local<v8::Value>());
 
     SetFastMethod(isolate, tmpl, "closePath", ClosePath, &fast_close_path_, v8::Local<v8::Value>());
 
-
     tmpl->Set(ConvertToV8String(isolate, "createImageData"),
               v8::FunctionTemplate::New(isolate, &CreateImageData));
     tmpl->Set(ConvertToV8String(isolate, "createPattern"),
@@ -352,6 +394,11 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
     tmpl->Set(ConvertToV8String(isolate, "drawFocusIfNeeded"),
               v8::FunctionTemplate::New(isolate, &DrawFocusIfNeeded));
 
+    tmpl->Set(ConvertToV8String(isolate, "drawAtlas"),
+              v8::FunctionTemplate::New(isolate, &DrawAtlas));
+
+
+//    SetFastMethod(isolate, tmpl, "drawAtlas", DrawAtlas, &fast_draw_atlas_, v8::Local<v8::Value>());
 
     SetFastMethodWithOverLoads(isolate, tmpl, "drawImage", DrawImage, fast_draw_overloads_,
                                v8::Local<v8::Value>());
@@ -365,6 +412,10 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
 
     tmpl->Set(ConvertToV8String(isolate, "fillText"),
               v8::FunctionTemplate::New(isolate, &FillText));
+
+
+    SetFastMethod(isolate, tmpl, "fillOval", FillOval, &fast_fill_oval_, v8::Local<v8::Value>());
+
     tmpl->Set(ConvertToV8String(isolate, "getImageData"),
               v8::FunctionTemplate::New(isolate, &GetImageData));
     tmpl->Set(ConvertToV8String(isolate, "getLineDash"),
@@ -444,6 +495,10 @@ v8::Local<v8::FunctionTemplate> CanvasRenderingContext2DImpl::GetCtor(v8::Isolat
     tmpl->Set(ConvertToV8String(isolate, "strokeText"),
               v8::FunctionTemplate::New(isolate, &StrokeText));
 
+
+    SetFastMethod(isolate, tmpl, "strokeOval", StrokeOval, &fast_stroke_oval_,
+                  v8::Local<v8::Value>());
+
     SetFastMethod(isolate, tmpl, "transform", Transform, &fast_transform_, v8::Local<v8::Value>());
 
 
@@ -466,6 +521,59 @@ RafImpl *CanvasRenderingContext2DImpl::GetRaf() {
     return this->raf_.get();
 }
 
+
+void CanvasRenderingContext2DImpl::__StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->StartRaf();
+
+}
+
+void CanvasRenderingContext2DImpl::__StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->StopRaf();
+
+}
+
+
+void CanvasRenderingContext2DImpl::GetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(false);
+        return;
+    }
+    info.GetReturnValue().Set(ptr->continuousRender_);
+}
+
+void CanvasRenderingContext2DImpl::SetContinuousRenderMode(v8::Local<v8::String> property,
+                                                           v8::Local<v8::Value> value,
+                                                           const v8::PropertyCallbackInfo<void> &info) {
+    CanvasRenderingContext2DImpl *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;
+}
+
+
 /* Non Standard 2D */
 
 void CanvasRenderingContext2DImpl::DrawPoint(const v8::FunctionCallbackInfo<v8::Value> &args) {
@@ -495,26 +603,16 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
     auto context = isolate->GetCurrentContext();
 
 
-    auto mode = ConvertFromV8String(isolate, args[0]);
+    auto mode = args[0];
     auto points = args[1].As<v8::Array>();
     auto size = points->Length();
 
-
-    if ((size % 2) == 0) {
-        int32_t pointMode = -1;
-        if (mode == "points") {
-            pointMode = 0;
-        } else if (mode == "lines") {
-            pointMode = 1;
-        } else if (mode == "polygon") {
-            pointMode = 2;
-        }
-        if (pointMode == -1) {
-            return;
-        }
+    if (size == 0) { return; }
+    uint32_t pointMode = 0;
+    if (mode->IsUint32() && mode->Uint32Value(context).To(&pointMode)) {
         std::vector<float> store;
-        store.reserve(size);
-        int next = 0;
+        auto len = size * 2;
+        store.reserve(len);
         for (int i = 0; i < size; i++) {
 
             auto object = points->Get(
@@ -526,10 +624,8 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
             auto y = object->Get(context,
                                  ConvertToV8String(isolate, "y")).ToLocalChecked()->NumberValue(
                     context).ToChecked();
-            store[next] = (float) x;
-            store[next + 1] = (float) y;
-
-            next = i + 2;
+            store.emplace_back((float) x);
+            store.emplace_back((float) y);
         }
 
         canvas_native_context_draw_points(
@@ -1285,7 +1381,7 @@ void CanvasRenderingContext2DImpl::GetLineDash(v8::Local<v8::String> property,
     auto ret = v8::Array::New(isolate, (int) size);
     for (int i = 0; i < size; i++) {
         auto item = buf[i];
-        ret->Set(context, i, v8::Number::New(isolate, (double) item));
+        ret->Set(context, i, v8::Number::New(isolate, (double) item)).FromJust();
     }
 
 }
@@ -1791,6 +1887,143 @@ CanvasRenderingContext2DImpl::DrawFocusIfNeeded(const v8::FunctionCallbackInfo<v
 }
 
 
+void
+CanvasRenderingContext2DImpl::DrawAtlas(const v8::FunctionCallbackInfo<v8::Value> &args) {
+
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto count = args.Length();
+    auto value = args[0];
+
+    if (value->IsNullOrUndefined() || !value->IsObject()) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto image = value.As<v8::Object>();
+    auto imageType = GetNativeType(image);
+
+
+    auto xformValue = args[1];
+    auto texValue = args[2];
+    auto colorsValue = args[3];
+    auto blendValue = args[4];
+
+    if (xformValue->IsArray() && texValue->IsArray()) {
+
+        std::vector<float> xform;
+        std::vector<float> tex;
+
+        v8::Local<v8::Array> xformArray = xformValue.As<v8::Array>();
+        v8::Local<v8::Array> texArray = texValue.As<v8::Array>();
+
+        auto xformLen = xformArray->Length();
+        xform.reserve(xformLen);
+        auto texLen = texArray->Length();
+        tex.reserve(texLen);
+
+
+        for (int i = 0; i < xformLen; i++) {
+            xform.emplace_back((float) xformArray->Get(context, i).ToLocalChecked()->NumberValue(
+                    context).ToChecked());
+        }
+
+        for (int i = 0; i < texLen; i++) {
+            tex.emplace_back((float) texArray->Get(context, i).ToLocalChecked()->NumberValue(
+                    context).ToChecked());
+        }
+
+        std::vector<std::string> colors;
+        std::vector<const char *> colors_ref;
+
+        // dst-over
+        int32_t mode = 4;
+
+        if (blendValue->IsInt32()) {
+            auto val = blendValue->Int32Value(context).To(&mode);
+        }
+
+        if (colorsValue->IsArray()) {
+            auto colorsArray = colorsValue.As<v8::Array>();
+            auto colorsLen = colorsArray->Length();
+            colors.reserve(colorsLen);
+            colors_ref.reserve(colorsLen);
+            for (int i = 0; i < colorsLen; i++) {
+                auto str = ConvertFromV8String(isolate, texArray->Get(context, i).ToLocalChecked());
+                colors.emplace_back(str);
+                colors_ref.emplace_back(str.c_str());
+            }
+        }
+
+        switch (imageType) {
+            case NativeType::ImageAsset: {
+                auto image_asset = ImageAssetImpl::GetPointer(image);
+
+                if (image_asset != nullptr) {
+
+                    if (colors.empty()) {
+                        canvas_native_context_draw_atlas_asset(ptr->GetContext(),
+                                                               image_asset->GetImageAsset(),
+                                                               xform.data(), xform.size(),
+                                                               tex.data(),
+                                                               tex.size(), nullptr,
+                                                               0, mode);
+                    } else {
+                        canvas_native_context_draw_atlas_asset(ptr->GetContext(),
+                                                               image_asset->GetImageAsset(),
+                                                               xform.data(), xform.size(),
+                                                               tex.data(),
+                                                               tex.size(), colors_ref.data(),
+                                                               colors_ref.size(), mode);
+                    }
+
+
+                    ptr->UpdateInvalidateState();
+                }
+            }
+                break;
+            case NativeType::ImageBitmap: {
+                auto image_bitmap = ImageBitmapImpl::GetPointer(image);
+                if (image_bitmap != nullptr) {
+                    if (colors.empty()) {
+                        canvas_native_context_draw_atlas_asset(ptr->GetContext(),
+                                                               image_bitmap->GetImageAsset(),
+                                                               xform.data(), xform.size(),
+                                                               tex.data(),
+                                                               tex.size(), nullptr,
+                                                               0, mode);
+                    } else {
+                        canvas_native_context_draw_atlas_asset(ptr->GetContext(),
+                                                               image_bitmap->GetImageAsset(),
+                                                               xform.data(), xform.size(),
+                                                               tex.data(),
+                                                               tex.size(), colors_ref.data(),
+                                                               colors_ref.size(), mode);
+                    }
+                }
+            }
+                break;
+            case NativeType::CanvasRenderingContext2D: {
+                auto image_canvas = CanvasRenderingContext2DImpl::GetPointer(image);
+                if (image_canvas != nullptr) {
+
+                    ptr->UpdateInvalidateState();
+                }
+            }
+                break;
+            default:
+                break;
+        }
+    }
+
+
+}
+
+
 void
 CanvasRenderingContext2DImpl::DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
@@ -1849,6 +2082,17 @@ CanvasRenderingContext2DImpl::DrawImage(const v8::FunctionCallbackInfo<v8::Value
                 }
             }
                 break;
+            case NativeType::WebGLRenderingContextBase: {
+                auto gl = WebGLRenderingContextBase::GetPointer(image);
+                if (gl != nullptr) {
+                    canvas_native_context_draw_image_dx_dy_webgl(
+                            ptr->GetContext(),
+                            gl->GetState(),
+                            dx, dy
+                    );
+                }
+            }
+                break;
             default:
                 break;
         }
@@ -1899,6 +2143,17 @@ CanvasRenderingContext2DImpl::DrawImage(const v8::FunctionCallbackInfo<v8::Value
                 }
             }
                 break;
+            case NativeType::WebGLRenderingContextBase: {
+                auto gl = WebGLRenderingContextBase::GetPointer(image);
+                if (gl != nullptr) {
+                    canvas_native_context_draw_image_dx_dy_dw_dh_webgl(
+                            ptr->GetContext(),
+                            gl->GetState(),
+                            dx, dy, dWidth, dHeight
+                    );
+                }
+            }
+                break;
             default:
                 break;
         }
@@ -1957,6 +2212,20 @@ CanvasRenderingContext2DImpl::DrawImage(const v8::FunctionCallbackInfo<v8::Value
                 }
             }
                 break;
+            case NativeType::WebGLRenderingContextBase: {
+                auto gl = WebGLRenderingContextBase::GetPointer(image);
+                if (gl != nullptr) {
+                    canvas_native_context_draw_image_webgl(
+                            ptr->GetContext(),
+                            gl->GetState(),
+                            sx,
+                            sy, sWidth, sHeight,
+                            dx,
+                            dy, dWidth, dHeight
+                    );
+                }
+            }
+                break;
             default:
                 break;
         }
@@ -2090,6 +2359,26 @@ CanvasRenderingContext2DImpl::FillText(const v8::FunctionCallbackInfo<v8::Value>
 
 }
 
+
+void
+CanvasRenderingContext2DImpl::FillOval(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto x = static_cast<float>(args[0]->NumberValue(context).ToChecked());
+    auto y = static_cast<float>(args[1]->NumberValue(context).ToChecked());
+    auto width = static_cast<float>(args[2]->NumberValue(context).ToChecked());
+    auto height = static_cast<float>(args[3]->NumberValue(context).ToChecked());
+    canvas_native_context_fill_oval(
+            ptr->GetContext(), x, y, width,
+            height);
+    ptr->UpdateInvalidateState();
+}
+
 void
 CanvasRenderingContext2DImpl::GetImageData(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
@@ -2150,7 +2439,7 @@ CanvasRenderingContext2DImpl::GetLineDash(const v8::FunctionCallbackInfo<v8::Val
     for (int i = 0; i < size; ++i) {
         array->Set(context, i,
                    v8::Number::New(isolate,
-                                   (double) buf[i]));
+                                   (double) buf[i])).FromJust();
     }
 
     args.GetReturnValue().Set(array);
@@ -2676,6 +2965,27 @@ CanvasRenderingContext2DImpl::StrokeText(const v8::FunctionCallbackInfo<v8::Valu
     }
 }
 
+void
+CanvasRenderingContext2DImpl::StrokeOval(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() == 4) {
+        auto x = static_cast<float>(args[0]->NumberValue(context).ToChecked());
+        auto y = static_cast<float>(args[1]->NumberValue(context).ToChecked());
+        auto width = static_cast<float>(args[2]->NumberValue(context).ToChecked());
+        auto height = static_cast<float>(args[3]->NumberValue(context).ToChecked());
+        canvas_native_context_stroke_oval(
+                ptr->GetContext(), x, y,
+                width,
+                height);
+        ptr->UpdateInvalidateState();
+    }
+}
+
+
 void
 CanvasRenderingContext2DImpl::Transform(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());
@@ -2785,11 +3095,7 @@ void CanvasRenderingContext2DImpl::Flush() {
     auto state = (int) this->GetInvalidateState() & (int) InvalidateState::InvalidateStatePending;
     if (state == (int) InvalidateState::InvalidateStatePending) {
         this->SetInvalidateState(InvalidateState::InvalidateStateInvalidating);
-        //   canvas_native_context_flush(ptr->GetContext());
-
         canvas_native_context_render(this->GetContext());
-        //        canvas_native_context_gl_make_current(ptr->GetContext());
-        //        canvas_native_context_gl_swap_buffers(ptr->GetContext());
         this->SetInvalidateState(InvalidateState::InvalidateStateNone);
     }
 }