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

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

@@ -4,15 +4,62 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import "NativeScript/JSIRuntime.h"
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
+#include "ObjectWrapperImpl.h"
+class WEBGL_compressed_texture_s3tcImpl: ObjectWrapperImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_compressed_texture_s3tcTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-using namespace facebook;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc"));
 
-class JSI_EXPORT WEBGL_compressed_texture_s3tcImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGB_S3TC_DXT1_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COMPRESSED_RGB_S3TC_DXT1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_S3TC_DXT1_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_S3TC_DXT3_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_S3TC_DXT5_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate,  GL_COMPRESSED_RGBA_S3TC_DXT5_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc"));
+
+        cache->WEBGL_compressed_texture_s3tcTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_compressed_texture_s3tcImpl *textureS3Tc) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_compressed_texture_s3tcImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WEBGL_compressed_texture_s3tc);
+        object->SetAlignedPointerInInternalField(0, textureS3Tc);
+        textureS3Tc->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_compressed_texture_s3tcImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_compressed_texture_s3tcImpl *>(ptr);
+    }
 };

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

@@ -4,16 +4,69 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import "NativeScript/JSIRuntime.h"
 #include "gl.h"
 #include <vector>
+#include "Caches.h"
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+class WEBGL_compressed_texture_s3tc_srgbImpl: ObjectWrapperImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_compressed_texture_s3tc_srgbTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-using namespace facebook;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc_srgb"));
 
-class JSI_EXPORT WEBGL_compressed_texture_s3tc_srgbImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB_S3TC_DXT1_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc_srgb"));
+
+        cache->WEBGL_compressed_texture_s3tc_srgbTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate,
+                WEBGL_compressed_texture_s3tc_srgbImpl *compressedTextureS3TcSrgb) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_compressed_texture_s3tc_srgbImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WEBGL_compressed_texture_s3tc_srgb);
+        object->SetAlignedPointerInInternalField(0, compressedTextureS3TcSrgb);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc_srgb"));
+        compressedTextureS3TcSrgb->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_compressed_texture_s3tc_srgbImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_compressed_texture_s3tc_srgbImpl *>(ptr);
+    }
 };
 

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

@@ -4,16 +4,56 @@
 
 #pragma
 
-#include "rust/cxx.h"
-#import "NativeScript/JSIRuntime.h"
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Caches.h"
+#include "Common.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
+class WEBGL_depth_textureImpl: ObjectWrapperImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_depth_textureTmpl.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, "WEBGL_depth_texture"));
 
-class JSI_EXPORT WEBGL_depth_textureImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        tmpl->Set(ConvertToV8String(isolate, "UNSIGNED_INT_24_8_WEBGL"), v8::Integer::NewFromUnsigned(isolate, 0x84FA));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_depth_texture"));
+
+        cache->WEBGL_depth_textureTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_depth_textureImpl *depthTexture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_depth_textureImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WEBGL_depth_texture);
+        object->SetAlignedPointerInInternalField(0, depthTexture);
+        depthTexture->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_depth_textureImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_depth_textureImpl *>(ptr);
+    }
 };

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

@@ -0,0 +1,38 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#include "WEBGL_draw_buffersImpl.h"
+
+WEBGL_draw_buffersImpl::WEBGL_draw_buffersImpl(WEBGL_draw_buffers *buffers) : buffers_(buffers) {
+
+}
+
+v8::CFunction WEBGL_draw_buffersImpl::fast_draw_buffers_webgl(
+        v8::CFunction::Make(WEBGL_draw_buffersImpl::FastDrawBuffersWEBGL));
+
+void WEBGL_draw_buffersImpl::DrawBuffersWEBGL(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WEBGL_draw_buffersImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto value = args[0];
+    if (value->IsArray()) {
+        auto buffers = value.As<v8::Array>();
+        auto len = buffers->Length();
+        std::vector<uint32_t> buf;
+        buf.reserve(len);
+        for (int j = 0; j < len; ++j) {
+            auto item = buffers->Get(context, j).ToLocalChecked();
+            buf.push_back(item->Uint32Value(context).ToChecked());
+        }
+        canvas_native_webgl_draw_buffers_draw_buffers_webgl(buf.data(), buf.size(),
+                                                            ptr->GetDrawBuffers());
+
+    }
+
+}

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

@@ -4,28 +4,171 @@
 
 #pragma once
 
-#include "canvas-cxx/src/lib.rs.h"
-
-#include "rust/cxx.h"
-#import "NativeScript/JSIRuntime.h"
 #include "gl.h"
 #include <vector>
+#include "Common.h"
+#include "Caches.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT WEBGL_draw_buffersImpl : public jsi::HostObject {
+class WEBGL_draw_buffersImpl : ObjectWrapperImpl {
 public:
-    WEBGL_draw_buffersImpl(rust::Box<WEBGL_draw_buffers> buffers);
+    WEBGL_draw_buffersImpl(WEBGL_draw_buffers *buffers);
+
+    static v8::CFunction fast_draw_buffers_webgl;
+
+    ~WEBGL_draw_buffersImpl() {
+        if (this->buffers_ != nullptr) {
+            canvas_native_webgl_WEBGL_draw_buffers_destroy(this->buffers_);
+            this->buffers_ = nullptr;
+        }
+    }
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_draw_buffersTmpl.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, "WEBGL_draw_buffers"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        SetFastMethod(isolate, tmpl, "drawBuffersWEBGL", DrawBuffersWEBGL,
+                      &fast_draw_buffers_webgl, v8::Local<v8::Value>());
+
+
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT0_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT0_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT1_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT2_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT2_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT3_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT3_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT4_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT4_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT5_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT5_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT6_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT6_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT7_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT7_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT8_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT8_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT9_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT9_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT10_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT10_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT11_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT11_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT12_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT12_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT13_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT13_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT14_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT14_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT15_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_COLOR_ATTACHMENT15_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER0_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER0_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER1_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER2_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER2_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER3_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER3_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER4_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER4_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER5_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER5_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER6_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER6_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER7_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER7_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER8_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER8_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER9_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER9_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER10_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER10_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER11_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER11_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER12_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER12_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER13_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER13_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER14_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER14_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER15_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_DRAW_BUFFER15_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "MAX_COLOR_ATTACHMENTS_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_MAX_COLOR_ATTACHMENTS_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "MAX_DRAW_BUFFERS_WEBGL"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_MAX_DRAW_BUFFERS_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_draw_buffers"));
+
+        cache->WEBGL_draw_buffersTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_draw_buffersImpl *buffers) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_draw_buffersImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::WEBGL_draw_buffers);
+        object->SetAlignedPointerInInternalField(0, buffers);
+        buffers->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_draw_buffersImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_draw_buffersImpl *>(ptr);
+    }
+
+    static void DrawBuffersWEBGL(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void
+    FastDrawBuffersWEBGL(v8::Local<v8::Object> receiver_obj, v8::Local<v8::Array> value) {
+        WEBGL_draw_buffersImpl *ptr = GetPointer(receiver_obj);
+        if (ptr == nullptr) {
+            return;
+        }
+
+
+        auto len = value->Length();
+        std::vector<uint32_t> buf;
+        buf.reserve(len);
+
+        auto copied = v8::TryToCopyAndConvertArrayToCppBuffer<v8::CTypeInfoBuilder<uint32_t>::Build().GetId(), uint32_t>(
+                value, buf.data(), len);
+
+        if (copied) {
+
+            canvas_native_webgl_draw_buffers_draw_buffers_webgl(buf.data(), buf.size(),
+                                                                ptr->GetDrawBuffers());
+        }
+    }
 
-    WEBGL_draw_buffers &GetDrawBuffers() {
-        return *this->buffers_;
+    WEBGL_draw_buffers *GetDrawBuffers() {
+        return this->buffers_;
     }
 
 private:
-    rust::Box<WEBGL_draw_buffers> buffers_;
+    WEBGL_draw_buffers *buffers_;
 };

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

@@ -0,0 +1,32 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#include "WEBGL_lose_contextImpl.h"
+
+
+WEBGL_lose_contextImpl::WEBGL_lose_contextImpl(WEBGL_lose_context* context) : context_(context){}
+
+
+void WEBGL_lose_contextImpl::LoseContext(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WEBGL_lose_contextImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    canvas_native_webgl_lose_context_lose_context(
+            ptr->GetContext());
+}
+
+
+void WEBGL_lose_contextImpl::RestoreContext(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WEBGL_lose_contextImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    canvas_native_webgl_lose_context_restore_context(
+            ptr->GetContext());
+}

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

@@ -4,28 +4,76 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import "NativeScript/JSIRuntime.h"
 #include "gl.h"
-#include "canvas-cxx/src/lib.rs.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
+#include "ObjectWrapperImpl.h"
+class WEBGL_lose_contextImpl: ObjectWrapperImpl {
+public:
+    WEBGL_lose_contextImpl(WEBGL_lose_context* context);
+    ~WEBGL_lose_contextImpl() {
+        canvas_native_webgl_WEBGL_lose_context_destroy(this->GetContext());
+        this->context_ = nullptr;
+    }
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_lose_contextTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-class JSI_EXPORT WEBGL_lose_contextImpl : public jsi::HostObject {
-public:
-    WEBGL_lose_contextImpl(rust::Box<WEBGL_lose_context> context);
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_lose_context"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        tmpl->Set(ConvertToV8String(isolate, "loseContext"),
+                  v8::FunctionTemplate::New(isolate, &LoseContext));
+        tmpl->Set(ConvertToV8String(isolate, "restoreContext"),
+                  v8::FunctionTemplate::New(isolate, &RestoreContext));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_lose_context"));
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        cache->WEBGL_lose_contextTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_lose_contextImpl *element) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_lose_contextImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WEBGL_lose_context);
+        object->SetAlignedPointerInInternalField(0, element);
+        element->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static WEBGL_lose_contextImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_lose_contextImpl *>(ptr);
+    }
+
+    static void LoseContext(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void RestoreContext(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    WEBGL_lose_context &GetContext() {
-        return *this->context_;
+    WEBGL_lose_context* GetContext() {
+        return this->context_;
     }
 
+
 private:
-    rust::Box<WEBGL_lose_context> context_;
+    WEBGL_lose_context* context_;
 };