@nativescript/canvas 2.0.0-beta.7 → 2.0.0-beta.8

package/platforms/ios/src/cpp/ImageAssetImpl.cpp

@@ -15,8 +15,8 @@ ImageAssetImpl::ImageAssetImpl(ImageAsset *asset) : asset_(asset) {
 }
 
 ImageAssetImpl::~ImageAssetImpl() {
-     canvas_native_image_asset_destroy(this->GetImageAsset());
-     asset_ = nullptr;
+    canvas_native_image_asset_destroy(this->GetImageAsset());
+    asset_ = nullptr;
 }
 
 void ImageAssetImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
@@ -62,6 +62,10 @@ v8::Local<v8::FunctionTemplate> ImageAssetImpl::GetCtor(v8::Isolate *isolate) {
             ConvertToV8String(isolate, "error"),
             GetError);
 
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "__addr"),
+            GetAddr);
+
     tmpl->Set(
             ConvertToV8String(isolate, "scale"),
             v8::FunctionTemplate::New(isolate, &Scale));
@@ -112,7 +116,7 @@ void ImageAssetImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto ret = args.This();
 
-    SetNativeType( ret, NativeType::ImageAsset);
+    SetNativeType(ret, NativeType::ImageAsset);
 
     auto image_asset = canvas_native_image_asset_create();
 
@@ -149,6 +153,21 @@ ImageAssetImpl::GetHeight(v8::Local<v8::String> name,
     info.GetReturnValue().Set(0);
 }
 
+
+void
+ImageAssetImpl::GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto addr = static_cast<intptr_t *>(static_cast<void *>(ptr->GetImageAsset()));
+        auto ret = std::to_string(*addr);
+        info.GetReturnValue().Set(ConvertToV8String(isolate, ret.c_str()));
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
 void
 ImageAssetImpl::GetError(v8::Local<v8::String> name,
                          const v8::PropertyCallbackInfo<v8::Value> &info) {

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

@@ -16,13 +16,13 @@
 
 class ImageAssetImpl: ObjectWrapperImpl{
 public:
-    
+
     ImageAssetImpl(ImageAsset* asset);
 
     ~ImageAssetImpl();
 
     ImageAsset* GetImageAsset();
-    
+
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
     static ImageAssetImpl *GetPointer(const v8::Local<v8::Object>& object);
@@ -37,6 +37,9 @@ public:
     static void GetHeight(v8::Local<v8::String> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
+    static void GetAddr(v8::Local<v8::String> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void GetError(v8::Local<v8::String> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 

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

@@ -15,6 +15,10 @@ v8::CFunction CanvasRenderingContext2DImpl::fast_stop_raf_(
 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));
 
@@ -389,6 +393,12 @@ 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>());
 
@@ -596,30 +606,30 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
     auto points = args[1].As<v8::Array>();
     auto size = points->Length();
 
-    if (size == 0){return;}
+    if (size == 0) { return; }
     uint32_t pointMode = 0;
-    if(mode->IsUint32() && mode->Uint32Value(context).To(&pointMode)){
+    if (mode->IsUint32() && mode->Uint32Value(context).To(&pointMode)) {
         std::vector<float> store;
         auto len = size * 2;
         store.reserve(len);
         for (int i = 0; i < size; i++) {
 
             auto object = points->Get(
-                                      context, i).ToLocalChecked().As<v8::Object>();
+                    context, i).ToLocalChecked().As<v8::Object>();
 
             auto x = object->Get(context,
                                  ConvertToV8String(isolate, "x")).ToLocalChecked()->NumberValue(
-                                                                                                context).ToChecked();
+                    context).ToChecked();
             auto y = object->Get(context,
                                  ConvertToV8String(isolate, "y")).ToLocalChecked()->NumberValue(
-                                                                                                context).ToChecked();
+                    context).ToChecked();
             store.emplace_back((float) x);
             store.emplace_back((float) y);
         }
 
         canvas_native_context_draw_points(
-                                          ptr->GetContext(), pointMode,
-                                          store.data(), store.size());
+                ptr->GetContext(), pointMode,
+                store.data(), store.size());
 
 
         ptr->UpdateInvalidateState();
@@ -1876,6 +1886,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()) {
+            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) {
 
@@ -2802,8 +2949,6 @@ CanvasRenderingContext2DImpl::StrokeOval(const v8::FunctionCallbackInfo<v8::Valu
 }
 
 
-
-
 void
 CanvasRenderingContext2DImpl::Transform(const v8::FunctionCallbackInfo<v8::Value> &args) {
     CanvasRenderingContext2DImpl *ptr = GetPointer(args.This());

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

@@ -126,6 +126,8 @@ public:
 
     static v8::CFunction fast_translate_;
 
+    static v8::CFunction fast_draw_atlas_;
+
 
     CanvasRenderingContext2DImpl(CanvasRenderingContext2D *context);
 
@@ -573,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