@nativescript/canvas 2.0.0-beta.9 → 2.0.0-rc.0

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

@@ -171,7 +171,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = CanvasRenderingContext2DImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::CanvasRenderingContext2D);
+        SetNativeType(renderingContext, NativeType::CanvasRenderingContext2D);
         object->SetAlignedPointerInInternalField(0, renderingContext);
         renderingContext->BindFinalizer(isolate, object);
         return scope.Escape(object);
@@ -503,9 +503,12 @@ public:
 
         switch (rule) {
             case 0:
+                canvas_native_context_clip_rule(
+                        ptr->GetContext(), CanvasFillRuleNonZero);
+                break;
             case 1:
                 canvas_native_context_clip_rule(
-                        ptr->GetContext(), rule);
+                        ptr->GetContext(), CanvasFillRuleEvenOdd);
                 break;
             default:
                 break;
@@ -521,7 +524,7 @@ public:
         if (GetNativeType(path_obj) == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
             canvas_native_context_clip(
-                    ptr->GetContext(), path->GetPath(), 0);
+                    ptr->GetContext(), path->GetPath(), CanvasFillRuleNonZero);
         }
 
 
@@ -536,8 +539,18 @@ public:
 
         if (GetNativeType(path_obj) == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
-            canvas_native_context_clip(
-                    ptr->GetContext(), path->GetPath(), rule);
+            switch (rule) {
+                case 0:
+                    canvas_native_context_clip(
+                            ptr->GetContext(), path->GetPath(), CanvasFillRuleNonZero);
+                    break;
+                case 1:
+                    canvas_native_context_clip(
+                            ptr->GetContext(), path->GetPath(), CanvasFillRuleEvenOdd);
+                    break;
+                default:
+                    break;
+            }
         }
 
     }
@@ -623,7 +636,7 @@ public:
     static void DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
-    DrawImageDxDyAssetImpl(CanvasRenderingContext2DImpl *ptr, ImageAsset *asset, double dx,
+    DrawImageDxDyAssetImpl(CanvasRenderingContext2DImpl *ptr, const ImageAsset *asset, double dx,
                            double dy) {
         if (asset != nullptr) {
             canvas_native_context_draw_image_dx_dy_asset(
@@ -677,7 +690,7 @@ public:
         }
     }
 
-    static void DrawImageDxDyDwDhAssetImpl(CanvasRenderingContext2DImpl *ptr, ImageAsset *asset,
+    static void DrawImageDxDyDwDhAssetImpl(CanvasRenderingContext2DImpl *ptr, const ImageAsset *asset,
                                            double dx, double dy, double dw, double dh) {
 
 
@@ -770,7 +783,7 @@ public:
 
     static void
     DrawImageAssetImpl(CanvasRenderingContext2DImpl *ptr,
-                       ImageAsset *asset, double sx,
+                       const ImageAsset *asset, double sx,
                        double sy, double sw, double sh, double dx, double dy, double dw,
                        double dh) {
 
@@ -884,10 +897,23 @@ public:
         auto object = Path2D::GetPointer(path);
 
         if (object != nullptr) {
-            canvas_native_context_fill_with_path(
-                    ptr->GetContext(),
-                    object->GetPath(),
-                    rule);
+            switch (rule) {
+                case 0:
+                    canvas_native_context_fill_with_path(
+                            ptr->GetContext(),
+                            object->GetPath(),
+                            CanvasFillRuleNonZero);
+                    break;
+                case 1:
+                    canvas_native_context_fill_with_path(
+                            ptr->GetContext(),
+                            object->GetPath(),
+                            CanvasFillRuleEvenOdd);
+                    break;
+                default:
+                    break;
+            }
+
             ptr->UpdateInvalidateState();
         }
     }
@@ -901,9 +927,10 @@ public:
 
         auto object = Path2D::GetPointer(path);
 
+
         canvas_native_context_fill_with_path(
                 ptr->GetContext(),
-                object->GetPath(), 0);
+                object->GetPath(), CanvasFillRuleNonZero);
         ptr->UpdateInvalidateState();
     }
 
@@ -913,8 +940,21 @@ public:
             return;
         }
 
-        canvas_native_context_fill(
-                ptr->GetContext(), rule);
+
+        switch (rule) {
+            case 0:
+                canvas_native_context_fill(
+                        ptr->GetContext(), CanvasFillRuleNonZero);
+                break;
+            case 1:
+                canvas_native_context_fill(
+                        ptr->GetContext(), CanvasFillRuleEvenOdd);
+                break;
+            default:
+                break;
+        }
+
+
         ptr->UpdateInvalidateState();
     }
 
@@ -925,7 +965,7 @@ public:
         }
 
         canvas_native_context_fill(
-                ptr->GetContext(), 0);
+                ptr->GetContext(), CanvasFillRuleNonZero);
         ptr->UpdateInvalidateState();
     }
 
@@ -986,7 +1026,8 @@ public:
         }
 
         return canvas_native_context_is_point_in_path(
-                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), 0);
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y),
+                CanvasFillRuleNonZero);
     }
 
     static bool
@@ -997,8 +1038,10 @@ public:
             return false;
         }
 
+
         return canvas_native_context_is_point_in_path(
-                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule);
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y),
+                rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
     }
 
     static bool
@@ -1018,10 +1061,22 @@ public:
         if (type == NativeType::Path2D) {
             auto path = Path2D::GetPointer(path_obj);
 
-
-            ret = canvas_native_context_is_point_in_path_with_path(
-                    ptr->GetContext(),
-                    path->GetPath(), x, y, rule);
+            switch (rule) {
+                case 0:
+
+                    ret = canvas_native_context_is_point_in_path_with_path(
+                            ptr->GetContext(),
+                            path->GetPath(), (float) x, (float) y, CanvasFillRuleNonZero);
+                    break;
+                case 1:
+
+                    ret = canvas_native_context_is_point_in_path_with_path(
+                            ptr->GetContext(),
+                            path->GetPath(), (float) x, (float) y, CanvasFillRuleEvenOdd);
+                    break;
+                default:
+                    break;
+            }
 
         }
         return ret;
@@ -1398,7 +1453,6 @@ public:
     static void StrokeText(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 
-
     static void StrokeOval(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 

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

@@ -23,9 +23,9 @@ public:
     }
 
     ~ImageDataBuffer() {
-        canvas_native_u8_buffer_destroy(slice_);
+        canvas_native_u8_buffer_release(slice_);
         slice_ = nullptr;
-        canvas_native_image_data_destroy(imageData_);
+        canvas_native_image_data_release(imageData_);
         imageData_ = nullptr;
     }
 
@@ -115,7 +115,7 @@ void ImageDataImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
         object->BindFinalizer(isolate, ret);
 
-        SetNativeType(ret, NativeType::ImageData);
+        SetNativeType(object, NativeType::ImageData);
 
         args.GetReturnValue().Set(ret);
         return;
@@ -136,7 +136,7 @@ void ImageDataImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
         ret->SetAlignedPointerInInternalField(0, object);
 
-        SetNativeType(ret, NativeType::ImageData);
+        SetNativeType(object, NativeType::ImageData);
 
         object->BindFinalizer(isolate, ret);
 
@@ -181,8 +181,7 @@ ImageDataImpl::GetData(v8::Local<v8::Name> name,
     if (ptr != nullptr) {
         auto isolate = info.GetIsolate();
 
-        auto data = new ImageDataBuffer(
-                canvas_native_image_data_get_shared_instance(ptr->GetImageData()));
+        auto data = new ImageDataBuffer(ptr->GetImageData());
 
         auto length = data->size();
         auto store = v8::ArrayBuffer::NewBackingStore(data->data(), length,

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

@@ -8,12 +8,12 @@
 #include "Common.h"
 #include "ObjectWrapperImpl.h"
 
-class ImageDataImpl: ObjectWrapperImpl {
+class ImageDataImpl : public ObjectWrapperImpl {
 public:
-    ImageDataImpl(ImageData* imageData);
-    
+    explicit ImageDataImpl(ImageData* imageData);
+
     ~ImageDataImpl(){
-        canvas_native_image_data_destroy(this->GetImageData());
+        canvas_native_image_data_release(this->GetImageData());
         this->imageData_ = nullptr;
     }
 

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

@@ -183,6 +183,71 @@ v8::Local<v8::FunctionTemplate> MatrixImpl::GetCtor(v8::Isolate *isolate) {
     );
 
 
+    tmpl->Set(
+            ConvertToV8String(isolate, "translate"),
+            v8::FunctionTemplate::New(isolate, Translate)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "translateSelf"),
+            v8::FunctionTemplate::New(isolate, TranslateSelf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "multiplySelf"),
+            v8::FunctionTemplate::New(isolate, MultiplySelf)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "premultiplySelf"),
+            v8::FunctionTemplate::New(isolate, PremultiplySelf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "scaleNonUniform"),
+            v8::FunctionTemplate::New(isolate, ScaleNonUniform)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "scaleNonUniformSelf"),
+            v8::FunctionTemplate::New(isolate, ScaleNonUniformSelf)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "rotate"),
+            v8::FunctionTemplate::New(isolate, Rotate)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "rotateSelf"),
+            v8::FunctionTemplate::New(isolate, RotateSelf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "skewX"),
+            v8::FunctionTemplate::New(isolate, SkewX)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "skewXSelf"),
+            v8::FunctionTemplate::New(isolate, SkewXSelf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "skewY"),
+            v8::FunctionTemplate::New(isolate, SkewY)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "skewYSelf"),
+            v8::FunctionTemplate::New(isolate, SkewYSelf)
+    );
+
+
     cache->MatrixTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
@@ -216,7 +281,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
                 ret->SetAlignedPointerInInternalField(0, object);
 
-                SetNativeType( ret, NativeType::Matrix);
+                SetNativeType(object, NativeType::Matrix);
 
                 object->BindFinalizer(isolate, ret);
 
@@ -242,7 +307,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
                 ret->SetAlignedPointerInInternalField(0, object);
 
-                SetNativeType( ret, NativeType::Matrix);
+                SetNativeType(object, NativeType::Matrix);
 
                 object->BindFinalizer(isolate, ret);
 
@@ -257,7 +322,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
         ret->SetAlignedPointerInInternalField(0, object);
 
-        SetNativeType( ret, NativeType::Matrix);
+        SetNativeType(object, NativeType::Matrix);
 
         object->BindFinalizer(isolate, ret);
 
@@ -802,6 +867,347 @@ void MatrixImpl::SetM44(v8::Local<v8::String> property,
     canvas_native_matrix_set_m44(ptr->GetMatrix(), (float) value->NumberValue(context).ToChecked());
 }
 
+
+void MatrixImpl::Translate(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 3) {
+        auto context = isolate->GetCurrentContext();
+        auto x = args[0];
+        auto y = args[1];
+        auto value = args[2];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_translate(
+                    (float) x->NumberValue(context).ToChecked(),
+                    (float) y->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(object, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::TranslateSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto x = args[0];
+        auto y = args[1];
+
+        canvas_native_matrix_translate_self(ptr->GetMatrix(),
+                                            (float) x->NumberValue(context).ToChecked(),
+                                            (float) y->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::MultiplySelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 1) {
+        auto context = isolate->GetCurrentContext();
+        auto value = args[0];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto matrix = GetPointer(value.As<v8::Object>());
+            canvas_native_matrix_multiply_self(ptr->GetMatrix(), matrix->GetMatrix());
+        }
+    }
+}
+
+void MatrixImpl::PremultiplySelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 1) {
+        auto context = isolate->GetCurrentContext();
+        auto value = args[0];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto matrix = GetPointer(value.As<v8::Object>());
+            canvas_native_matrix_premultiply_self(ptr->GetMatrix(), matrix->GetMatrix());
+        }
+    }
+}
+
+void MatrixImpl::ScaleNonUniform(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 3) {
+        auto context = isolate->GetCurrentContext();
+        auto sx = args[0];
+        auto sy = args[1];
+        auto value = args[2];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_scale_non_uniform(
+                    (float) sx->NumberValue(context).ToChecked(),
+                    (float) sy->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(object, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::ScaleNonUniformSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto x = args[0];
+        auto y = args[1];
+        canvas_native_matrix_scale_non_uniform_self(ptr->GetMatrix(),
+                                                    (float) x->NumberValue(context).ToChecked(),
+                                                    (float) y->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::Rotate(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 4) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        auto cx = args[1];
+        auto cy = args[2];
+        auto value = args[3];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_rotate(
+                    (float) angle->NumberValue(context).ToChecked(),
+                    (float) cx->NumberValue(context).ToChecked(),
+                    (float) cy->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(object, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::RotateSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        auto cx = args[1];
+        auto cy = args[2];
+        canvas_native_matrix_rotate_self(ptr->GetMatrix(),
+                                         (float) angle->NumberValue(context).ToChecked(),
+                                         (float) cx->NumberValue(context).ToChecked(),
+                                         (float) cy->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::SkewX(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        auto value = args[1];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_skew_x(
+                    (float) angle->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(object, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::SkewXSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 1) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        canvas_native_matrix_skew_x_self(ptr->GetMatrix(),
+                                         (float) angle->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::SkewY(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+
+    if (count >= 2) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        auto value = args[1];
+        auto type = GetNativeType(value);
+        if (type == NativeType::Matrix) {
+            auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
+            auto matrix = canvas_native_matrix_skew_y(
+                    (float) angle->NumberValue(context).ToChecked(),
+                    ptr->GetMatrix());
+            if (matrix == nullptr) {
+                args.GetReturnValue().SetUndefined();
+                return;
+            }
+
+
+            auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+                    context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+            auto object = new MatrixImpl(matrix);
+
+            ret->SetAlignedPointerInInternalField(0, object);
+
+            SetNativeType(object, NativeType::Matrix);
+
+            object->BindFinalizer(isolate, ret);
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void MatrixImpl::SkewYSelf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto count = args.Length();
+    auto isolate = args.GetIsolate();
+
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    if (count >= 1) {
+        auto context = isolate->GetCurrentContext();
+        auto angle = args[0];
+        canvas_native_matrix_skew_y_self(ptr->GetMatrix(),
+                                         (float) angle->NumberValue(context).ToChecked());
+    }
+}
+
+void MatrixImpl::Clone(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    MatrixImpl *ptr = GetPointer(args.This());
+
+    auto matrix = canvas_native_matrix_clone(ptr->GetMatrix());
+
+
+    auto ret = MatrixImpl::GetCtor(isolate)->GetFunction(
+            context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+    auto object = new MatrixImpl(matrix);
+
+    ret->SetAlignedPointerInInternalField(0, object);
+
+    SetNativeType(object, NativeType::Matrix);
+
+    object->BindFinalizer(isolate, ret);
+
+    args.GetReturnValue().Set(ret);
+}
+
+
 Matrix *MatrixImpl::GetMatrix() {
     return this->matrix_;
 }
+
+