@nativescript/canvas 2.0.0-alpha.3 → 2.0.0-alpha.31

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

@@ -4,33 +4,51 @@
 
 #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));
     auto raf_callback = new OnRafCallback(
-            ctx_ptr,
-            version == WebGLRenderingVersion::V2 ? 2 : 1);
+                                          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)));
-
+                 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::StartRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_start(raf->GetRaf());
+        }
+    }
+}
+
 
+void WebGLRenderingContextBase::StopRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_stop(raf->GetRaf());
+        }
+    }
 }
 
+
 void WebGLRenderingContextBase::UpdateInvalidateState() {
     auto raf = this->GetRaf();
     if (raf != nullptr) {
@@ -39,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);
     }
 }
 
@@ -59,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) {
@@ -91,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,28 +5,31 @@
 #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 "Common.h"
 
 enum class WebGLRenderingVersion : uint8_t {
     V1,
     V2
 };
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class WebGLRenderingContextBase : public jsi::HostObject {
+class WebGLRenderingContextBase {
 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->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLRenderingContextBase *>(ptr);
+    }
 
     ~WebGLRenderingContextBase();
 
@@ -42,7 +45,7 @@ public:
 
     static void Flush(intptr_t context);
 
-    WebGLState &GetState();
+    WebGLState* GetState();
 
     void SetRaf(std::shared_ptr<RafImpl> raf);
 
@@ -50,13 +53,16 @@ public:
 
     WebGLRenderingVersion GetVersion() const;
 
+    void StartRaf();
+
+    void StopRaf();
 
 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_;
 };

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"
+#include "Helpers.h"
 
-using namespace facebook;
-
-class JSI_EXPORT WebGLShader : public jsi::HostObject {
+class WebGLShader {
 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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLShader"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        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(isolate, object, NativeType::WebGLShader);
+        auto ext = v8::External::New(isolate, shader);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLShader *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        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::String> 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::String> 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::String> 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"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
 
-class WebGLShaderPrecisionFormatImpl : public jsi::HostObject {
+class WebGLShaderPrecisionFormatImpl {
 public:
-    WebGLShaderPrecisionFormatImpl(rust::Box<WebGLShaderPrecisionFormat> shader);
+    WebGLShaderPrecisionFormatImpl(WebGLShaderPrecisionFormat* shader);
+    
+    ~WebGLShaderPrecisionFormatImpl() {
+        canvas_native_webgl_shader_precision_format_destroy(this->GetShaderPrecisionFormat());
+        this->shader_ = nullptr;
+    }
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    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);
+        }
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLShaderPrecisionFormat"));
 
-    WebGLShaderPrecisionFormat &GetShaderPrecisionFormat();
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->SetAccessor(ConvertToV8String(isolate, "rangeMin"), &GetRangeMin);
+        tmpl->SetAccessor(ConvertToV8String(isolate, "rangeMax"), &GetRangeMax);
+        tmpl->SetAccessor(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(isolate, object, NativeType::WebGLShaderPrecisionFormat);
+        auto ext = v8::External::New(isolate, shaderPrecisionFormat);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLShaderPrecisionFormatImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLShaderPrecisionFormatImpl *>(ptr);
+    }
+
+
+    static void GetRangeMin(v8::Local<v8::String> property,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetRangeMax(v8::Local<v8::String> property,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetPrecision(v8::Local<v8::String> property,
+                             const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    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"
+#include "Helpers.h"
 
-using namespace facebook;
-
-class JSI_EXPORT WebGLTexture : public jsi::HostObject {
+class WebGLTexture {
 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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLTexture"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        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(isolate, object, NativeType::WebGLTexture);
+        auto ext = v8::External::New(isolate, texture);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLTexture *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        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"
 
-using namespace facebook;
 
-
-class JSI_EXPORT WebGLUniformLocation
-
-        : public jsi::HostObject {
+class WebGLUniformLocation {
 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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLUniformLocation"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        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(isolate, object, NativeType::WebGLUniformLocation);
+        auto ext = v8::External::New(isolate, uniformLocation);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLUniformLocation *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        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,126 @@
+//
+// 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) {}
+
+ANGLE_instanced_arraysImpl *
+ANGLE_instanced_arraysImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    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(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "ANGLE_instanced_arrays"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+
+    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"));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "drawArraysInstancedANGLE"),
+            v8::FunctionTemplate::New(isolate, &DrawArraysInstancedANGLE));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "drawElementsInstancedANGLE"),
+            v8::FunctionTemplate::New(isolate, &DrawElementsInstancedANGLE));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttribDivisorANGLE"),
+            v8::FunctionTemplate::New(isolate, &VertexAttribDivisorANGLE));
+
+
+    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_;
+}

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

@@ -4,25 +4,39 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
+#include "Helpers.h"
 #include <vector>
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
 
-class JSI_EXPORT ANGLE_instanced_arraysImpl : public jsi::HostObject {
+class ANGLE_instanced_arraysImpl {
 public:
-    ANGLE_instanced_arraysImpl(rust::Box<ANGLE_instanced_arrays> arrays);
+    ANGLE_instanced_arraysImpl(ANGLE_instanced_arrays *arrays);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    ANGLE_instanced_arrays *GetArrays();
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static ANGLE_instanced_arraysImpl *GetPointer(const v8::Local<v8::Object> &object);
 
-    ANGLE_instanced_arrays &GetArrays();
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, ANGLE_instanced_arraysImpl *arrays) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = ANGLE_instanced_arraysImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::ANGLE_instanced_arrays);
+        auto ext = v8::External::New(isolate, arrays);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static void DrawArraysInstancedANGLE(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawElementsInstancedANGLE(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribDivisorANGLE(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    rust::Box<ANGLE_instanced_arrays> arrays_;
+    ANGLE_instanced_arrays *arrays_;
 };