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

package/platforms/ios/src/cpp/webgl/{WebGLRenderingContextBase.mm → WebGLRenderingContextBase.cpp}

@@ -4,9 +4,9 @@
 
 #include "WebGLRenderingContextBase.h"
 
-WebGLRenderingContextBase::WebGLRenderingContextBase(rust::Box<WebGLState> state,
+WebGLRenderingContextBase::WebGLRenderingContextBase(WebGLState* state,
                                                      WebGLRenderingVersion version)
-: state_(std::move(state)), version_(version) {
+: state_(state), version_(version) {
     
     
     auto ctx_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(this));
@@ -14,14 +14,11 @@ WebGLRenderingContextBase::WebGLRenderingContextBase(rust::Box<WebGLState> state
                                           ctx_ptr,
                                           version == WebGLRenderingVersion::V2 ? 2 : 1);
     auto raf_callback_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(raf_callback));
-    auto raf = canvas_native_raf_create(
-                                        raf_callback_ptr);
+    auto raf = canvas_native_raf_create(raf_callback_ptr, OnRafCallbackOnFrame);
     this->SetRaf(
                  std::make_shared<RafImpl>(
                                            raf_callback,
-                                           raf_callback_ptr,
-                                           std::move(
-                                                     raf)));
+                                           raf_callback_ptr, raf));
     
     auto _raf = this->GetRaf();
     
@@ -29,7 +26,6 @@ WebGLRenderingContextBase::WebGLRenderingContextBase(rust::Box<WebGLState> state
         canvas_native_raf_start(_raf->GetRaf());
     }
     
-    UpdateBindings();
 }
 
 
@@ -52,6 +48,7 @@ void WebGLRenderingContextBase::StopRaf() {
     }
 }
 
+
 void WebGLRenderingContextBase::UpdateInvalidateState() {
     auto raf = this->GetRaf();
     if (raf != nullptr) {
@@ -60,16 +57,16 @@ void WebGLRenderingContextBase::UpdateInvalidateState() {
         }
     }
     auto state = this->GetInvalidateState();
-    this->SetInvalidateState(state | (int) InvalidateState::PENDING);
+    this->SetInvalidateState(state | (int) InvalidateState::InvalidateStatePending);
 }
 
 void WebGLRenderingContextBase::Flush() {
-    auto state = this->GetInvalidateState() & (int) InvalidateState::PENDING;
-    if (state == (int) InvalidateState::PENDING) {
-        this->SetInvalidateState((int) InvalidateState::INVALIDATING);
+    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());
-        this->SetInvalidateState((int) InvalidateState::NONE);
+        this->SetInvalidateState((int) InvalidateState::InvalidateStateNone);
     }
 }
 
@@ -80,8 +77,8 @@ void WebGLRenderingContextBase::Flush(intptr_t context) {
     }
 }
 
-WebGLState &WebGLRenderingContextBase::GetState() {
-    return *this->state_;
+WebGLState* WebGLRenderingContextBase::GetState() {
+    return this->state_;
 }
 
 void WebGLRenderingContextBase::SetRaf(std::shared_ptr<RafImpl> raf) {
@@ -112,7 +109,11 @@ WebGLRenderingVersion WebGLRenderingContextBase::GetVersion() const {
 WebGLRenderingContextBase::~WebGLRenderingContextBase() {
     auto _raf = this->GetRaf();
     if (_raf != nullptr) {
-        canvas_native_raf_start(
-                                _raf->GetRaf());
+        canvas_native_raf_stop(
+                               _raf->GetRaf());
     }
+    canvas_native_raf_destroy(_raf->GetRaf());
+    this->raf_ = nullptr;
+    canvas_native_webgl_state_destroy(this->GetState());
+    this->state_ = nullptr;
 }

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

@@ -5,29 +5,32 @@
 #pragma once
 #pragma process_pending_includes
 
-#import "NativeScript/JSIRuntime.h"
-#include "rust/cxx.h"
 #include <vector>
 #include <cstdint>
 #include <memory>
-#include "canvas-cxx/src/lib.rs.h"
 
 #include "Helpers.h"
 #include "RafImpl.h"
 #include "OnRafCallback.h"
-#include "gl.h"
+#include "Common.h"
+#include "ObjectWrapperImpl.h"
 
 enum class WebGLRenderingVersion : uint8_t {
     V1,
     V2
 };
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class WebGLRenderingContextBase : public jsi::HostObject {
+class WebGLRenderingContextBase: public ObjectWrapperImpl {
 public:
-    WebGLRenderingContextBase(rust::Box<WebGLState> state, WebGLRenderingVersion version);
+    WebGLRenderingContextBase(WebGLState* state, WebGLRenderingVersion version);
+
+    static WebGLRenderingContextBase *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLRenderingContextBase *>(ptr);
+    }
 
     ~WebGLRenderingContextBase();
 
@@ -43,48 +46,25 @@ public:
 
     static void Flush(intptr_t context);
 
-    WebGLState &GetState();
+    WebGLState* GetState();
 
     void SetRaf(std::shared_ptr<RafImpl> raf);
 
     RafImpl *GetRaf();
 
     WebGLRenderingVersion GetVersion() const;
-    
-    int GetDisplayFramebuffer(){
-        return displayFramebuffer_;
-    }
 
-    int GetDisplayRenderbuffer(){
-        return displayRenderbuffer_;
-    }
-    
     void StartRaf();
+
     void StopRaf();
-    
-    void UpdateBindings(){
-        auto displayFramebuffer = canvas_native_webgl_get_parameter(GL_FRAMEBUFFER_BINDING, *state_);
-        
-        auto displayRenderbuffer = canvas_native_webgl_get_parameter(GL_RENDERER, *state_);
-        
-        if(!canvas_native_webgl_result_get_is_none(*displayFramebuffer)){
-            displayFramebuffer_ = canvas_native_webgl_result_get_i32(*displayFramebuffer);
-        }
-        
-        if(!canvas_native_webgl_result_get_is_none(*displayRenderbuffer)){
-            displayRenderbuffer_ = canvas_native_webgl_result_get_i32(*displayRenderbuffer);
-        }
-    }
 
 private:
-    rust::Box<WebGLState> state_;
+    WebGLState* state_;
 
     WebGLRenderingVersion version_;
 
-    int invalidateState_ = static_cast<int>(InvalidateState::NONE);
+    int invalidateState_ = static_cast<int>(InvalidateState::InvalidateStateNone);
 
     std::shared_ptr<RafImpl> raf_;
-    int displayFramebuffer_;
-    int displayRenderbuffer_;
 };
 

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

@@ -4,16 +4,50 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
-
-using namespace facebook;
-
-class JSI_EXPORT WebGLShader : public jsi::HostObject {
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+class WebGLShader: ObjectWrapperImpl {
 public:
     WebGLShader(uint32_t shader) : shader_(shader) {}
 
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLShaderTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLShader"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        cache->WebGLShaderTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLShader *shader) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLShader::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLShader);
+        object->SetAlignedPointerInInternalField(0, shader);
+        shader->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGLShader *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLShader *>(ptr);
+    }
+
     uint32_t GetShader() {
         return this->shader_;
     }

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

@@ -0,0 +1,50 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#include "WebGLShaderPrecisionFormatImpl.h"
+
+WebGLShaderPrecisionFormatImpl::WebGLShaderPrecisionFormatImpl(
+                                                               WebGLShaderPrecisionFormat* shader) : shader_(shader) {}
+
+
+void WebGLShaderPrecisionFormatImpl::GetRangeMin(v8::Local<v8::Name> property,
+                                                 const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
+    }
+
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_range_min(
+            ptr->GetShaderPrecisionFormat()));
+}
+
+void WebGLShaderPrecisionFormatImpl::GetRangeMax(v8::Local<v8::Name> property,
+                                                 const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
+    }
+
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_range_max(
+            ptr->GetShaderPrecisionFormat()));
+}
+
+
+void WebGLShaderPrecisionFormatImpl::GetPrecision(v8::Local<v8::Name> property,
+                                                  const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
+    }
+
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_precision(
+            ptr->GetShaderPrecisionFormat()));
+}
+
+WebGLShaderPrecisionFormat* WebGLShaderPrecisionFormatImpl::GetShaderPrecisionFormat() {
+    return this->shader_;
+}

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

@@ -4,25 +4,80 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
 #include <vector>
+#include "Helpers.h"
+#include "Caches.h"
+#include "Common.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class WebGLShaderPrecisionFormatImpl : public jsi::HostObject {
+class WebGLShaderPrecisionFormatImpl: ObjectWrapperImpl {
 public:
-    WebGLShaderPrecisionFormatImpl(rust::Box<WebGLShaderPrecisionFormat> shader);
+    WebGLShaderPrecisionFormatImpl(WebGLShaderPrecisionFormat* shader);
+
+    ~WebGLShaderPrecisionFormatImpl() {
+        canvas_native_webgl_shader_precision_format_destroy(this->GetShaderPrecisionFormat());
+        this->shader_ = nullptr;
+    }
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLShaderPrecisionFormatTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLShaderPrecisionFormat"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        tmpl->SetLazyDataProperty(ConvertToV8String(isolate, "rangeMin"), GetRangeMin);
+        tmpl->SetLazyDataProperty(ConvertToV8String(isolate, "rangeMax"), GetRangeMax);
+        tmpl->SetLazyDataProperty(ConvertToV8String(isolate, "precision"), GetPrecision);
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WebGLShaderPrecisionFormat"));
+
+        cache->WebGLShaderPrecisionFormatTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLShaderPrecisionFormatImpl *shaderPrecisionFormat) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLShaderPrecisionFormatImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLShaderPrecisionFormat);
+        object->SetAlignedPointerInInternalField(0, shaderPrecisionFormat);
+        shaderPrecisionFormat->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGLShaderPrecisionFormatImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLShaderPrecisionFormatImpl *>(ptr);
+    }
+
+
+    static void GetRangeMin(v8::Local<v8::Name> property,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void GetRangeMax(v8::Local<v8::Name> property,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void GetPrecision(v8::Local<v8::Name> property,
+                             const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    WebGLShaderPrecisionFormat &GetShaderPrecisionFormat();
+    WebGLShaderPrecisionFormat* GetShaderPrecisionFormat();
 
 private:
-    rust::Box<WebGLShaderPrecisionFormat> shader_;
+    WebGLShaderPrecisionFormat* shader_;
 };
 

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

@@ -4,16 +4,50 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
-
-using namespace facebook;
-
-class JSI_EXPORT WebGLTexture : public jsi::HostObject {
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+class WebGLTexture: ObjectWrapperImpl {
 public:
     WebGLTexture(uint32_t texture) : texture_(texture) {}
 
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLTextureTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLTexture"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        cache->WebGLTextureTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLTexture *texture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLTexture::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLTexture);
+        object->SetAlignedPointerInInternalField(0, texture);
+        texture->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGLTexture *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLTexture *>(ptr);
+    }
+
     uint32_t GetTexture() {
         return this->texture_;
     }

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

@@ -4,21 +4,57 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-
-
-class JSI_EXPORT WebGLUniformLocation
-
-        : public jsi::HostObject {
+class WebGLUniformLocation: ObjectWrapperImpl {
 public:
     WebGLUniformLocation(int32_t
                          uniformLocation) :
             uniformLocation_(uniformLocation) {}
 
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLUniformLocationTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLUniformLocation"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        cache->WebGLUniformLocationTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLUniformLocation *uniformLocation) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLUniformLocation::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLUniformLocation);
+        object->SetAlignedPointerInInternalField(0, uniformLocation);
+        uniformLocation->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGLUniformLocation *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLUniformLocation *>(ptr);
+    }
+
     int32_t GetUniformLocation() {
         return this->uniformLocation_;
     }

package/platforms/ios/src/cpp/webgl/extensions/ANGLE_instanced_arraysImpl.cpp

@@ -0,0 +1,136 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#include "ANGLE_instanced_arraysImpl.h"
+#include "Caches.h"
+
+ANGLE_instanced_arraysImpl::ANGLE_instanced_arraysImpl(ANGLE_instanced_arrays *arrays)
+        : arrays_(arrays) {}
+
+
+v8::CFunction ANGLE_instanced_arraysImpl::fast_draw_arrays_instanced_angle_(
+        v8::CFunction::Make(ANGLE_instanced_arraysImpl::FastDrawArraysInstancedANGLE));
+
+
+v8::CFunction ANGLE_instanced_arraysImpl::fast_draw_elements_instanced_angle_(
+        v8::CFunction::Make(ANGLE_instanced_arraysImpl::FastDrawElementsInstancedANGLE));
+
+v8::CFunction ANGLE_instanced_arraysImpl::fast_vertex_attrib_divisor_angle_(
+        v8::CFunction::Make(ANGLE_instanced_arraysImpl::FastVertexAttribDivisorANGLE));
+
+
+ANGLE_instanced_arraysImpl *
+ANGLE_instanced_arraysImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<ANGLE_instanced_arraysImpl *>(ptr);
+}
+
+void ANGLE_instanced_arraysImpl::DrawArraysInstancedANGLE(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    ANGLE_instanced_arraysImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto mode = args[0]->Uint32Value(context).ToChecked();
+    auto first = args[1]->Int32Value(context).ToChecked();
+    auto count_ = args[2]->Int32Value(context).ToChecked();
+    auto primcount = args[3]->Int32Value(context).ToChecked();
+
+    canvas_native_webgl_angle_instanced_arrays_draw_arrays_instanced_angle(
+            mode,
+            first,
+            count_,
+            primcount,
+            ptr->GetArrays()
+    );
+}
+
+void ANGLE_instanced_arraysImpl::DrawElementsInstancedANGLE(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    ANGLE_instanced_arraysImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto mode = args[0]->Uint32Value(context).ToChecked();
+    auto count = args[1]->Int32Value(context).ToChecked();
+    auto type = args[2]->Uint32Value(context).ToChecked();
+    auto offset = args[3]->Int32Value(context).ToChecked();
+    auto primcount = args[4]->Int32Value(context).ToChecked();
+    canvas_native_webgl_angle_instanced_arrays_draw_elements_instanced_angle(
+            mode,
+            count,
+            type,
+            offset,
+            primcount,
+            ptr->GetArrays()
+    );
+}
+
+void ANGLE_instanced_arraysImpl::VertexAttribDivisorANGLE(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    ANGLE_instanced_arraysImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto index = args[0]->Uint32Value(context).ToChecked();
+    auto divisor = args[1]->Uint32Value(context).ToChecked();
+    canvas_native_webgl_angle_instanced_arrays_vertex_attrib_divisor_angle(
+            index,
+            divisor,
+            ptr->GetArrays()
+    );
+}
+
+
+v8::Local<v8::FunctionTemplate> ANGLE_instanced_arraysImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->ANGLE_instanced_arraysTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "ANGLE_instanced_arrays"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->Set(ConvertToV8String(isolate, "VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE"),
+              v8::Integer::NewFromUnsigned(isolate, 0x88FE));
+
+    tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+              ConvertToV8String(isolate, "ANGLE_instanced_arrays"));
+
+
+    SetFastMethod(isolate, tmpl, "drawArraysInstancedANGLE", DrawArraysInstancedANGLE,
+                  &fast_draw_arrays_instanced_angle_, v8::Local<v8::Value>());
+
+    SetFastMethod(isolate, tmpl, "drawElementsInstancedANGLE", DrawElementsInstancedANGLE,
+                  &fast_draw_elements_instanced_angle_, v8::Local<v8::Value>());
+
+    SetFastMethod(isolate, tmpl, "vertexAttribDivisorANGLE", VertexAttribDivisorANGLE,
+                  &fast_vertex_attrib_divisor_angle_, v8::Local<v8::Value>());
+
+
+    cache->ANGLE_instanced_arraysTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+ANGLE_instanced_arrays *ANGLE_instanced_arraysImpl::GetArrays() {
+    return this->arrays_;
+}