@nativescript/canvas 2.0.0-alpha.20 → 2.0.0-alpha.21

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

@@ -4,29 +4,84 @@
 
 #pragma once
 
-#include "canvas-cxx/src/lib.rs.h"
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
-#include "../../webgl2/WebGLVertexArrayObject.h"
+#include "WebGLVertexArrayObject.h"
 #include "Helpers.h"
 #include <vector>
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT OES_vertex_array_objectImpl : public jsi::HostObject {
+class OES_vertex_array_objectImpl {
 public:
-    OES_vertex_array_objectImpl(rust::Box<OES_vertex_array_object> object);
+    OES_vertex_array_objectImpl(OES_vertex_array_object* object);
+    ~OES_vertex_array_objectImpl(){
+        canvas_native_webgl_OES_vertex_array_object_destroy(this->GetVertexArrayObject());
+        this->object_ = nullptr;
+    }
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->OES_vertex_array_objectTmpl.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, "OES_vertex_array_object"));
 
-    OES_vertex_array_object &GetVertexArrayObject() {
-        return *this->object_;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "OES_vertex_array_object"));
+        tmpl->Set(ConvertToV8String(isolate, "VERTEX_ARRAY_BINDING_OES"),
+                  v8::Number::New(isolate, (double) GL_VERTEX_ARRAY_BINDING_OES));
+        tmpl->Set(ConvertToV8String(isolate, "createVertexArrayOES"),
+                  v8::FunctionTemplate::New(isolate, &CreateVertexArrayOES));
+        tmpl->Set(ConvertToV8String(isolate, "deleteVertexArrayOES"),
+                  v8::FunctionTemplate::New(isolate, &DeleteVertexArrayOES));
+        tmpl->Set(ConvertToV8String(isolate, "isVertexArrayOES"),
+                  v8::FunctionTemplate::New(isolate, &IsVertexArrayOES));
+        tmpl->Set(ConvertToV8String(isolate, "bindVertexArrayOES"),
+                  v8::FunctionTemplate::New(isolate, &BindVertexArrayOES));
+
+
+        cache->OES_vertex_array_objectTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
     }
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, OES_vertex_array_objectImpl *vertexArrayObject) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = OES_vertex_array_objectImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::OES_vertex_array_object);
+        auto ext = v8::External::New(isolate, vertexArrayObject);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static OES_vertex_array_objectImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<OES_vertex_array_objectImpl *>(ptr);
+    }
+
+    static void CreateVertexArrayOES(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteVertexArrayOES(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsVertexArrayOES(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindVertexArrayOES(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+    OES_vertex_array_object * GetVertexArrayObject() {
+        return this->object_;
+    }
 
 private:
-    rust::Box<OES_vertex_array_object> object_;
+    OES_vertex_array_object* object_;
 };

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

@@ -4,17 +4,60 @@
 
 #define once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
-
-class JSI_EXPORT WEBGL_color_buffer_floatImpl : public jsi::HostObject {
+class WEBGL_color_buffer_floatImpl {
 public:
-    std::string ext_name_ = "WEBGL_color_buffer_float";
-    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->WEBGL_color_buffer_floatTmpl.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, "WEBGL_color_buffer_float"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_color_buffer_float"));
+
+        tmpl->Set(ConvertToV8String(isolate, "RGBA32F_EXT"),
+                  v8::Number::New(isolate, (double) GL_RGBA32F_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "RGB32F_EXT"),
+                  v8::Number::New(isolate, (double) GL_RGB32F_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT"),
+                  v8::Number::New(isolate, (double) GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "UNSIGNED_NORMALIZED_EXT"),
+                  v8::Number::New(isolate, (double) GL_UNSIGNED_NORMALIZED_EXT));
+        cache->WEBGL_color_buffer_floatTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_color_buffer_floatImpl *buffer) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_color_buffer_floatImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WEBGL_color_buffer_float);
+        auto ext = v8::External::New(isolate, buffer);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static WEBGL_color_buffer_floatImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_color_buffer_floatImpl *>(ptr);
+    }
 };

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

@@ -4,15 +4,58 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
+class WEBGL_compressed_texture_atcImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_compressed_texture_atcTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-class JSI_EXPORT WEBGL_compressed_texture_atcImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_atc"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_compressed_texture_atc"));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGB_ATC_WEBGL"),
+                  v8::Number::New(isolate, (double) GL_ATC_RGB_AMD));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL"),
+                  v8::Number::New(isolate, (double) GL_ATC_RGBA_EXPLICIT_ALPHA_AMD));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL"),
+                  v8::Number::New(isolate, (double) GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD));
+
+        cache->WEBGL_compressed_texture_atcTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_compressed_texture_atcImpl *compressedTextureAtc) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_compressed_texture_atcImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WEBGL_compressed_texture_atc);
+        auto ext = v8::External::New(isolate, compressedTextureAtc);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_compressed_texture_atcImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_compressed_texture_atcImpl *>(ptr);
+    }
 };

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

@@ -4,15 +4,56 @@
 
 #pragma once
 
-#import "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
-#import "gl.h"
-#import <vector>
+#include "gl.h"
+#include <vector>
+#include "Common.h"
+#include "Caches.h"
+#include "Helpers.h"
 
-using namespace facebook;
+class WEBGL_compressed_texture_etc1Impl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_compressed_texture_etc1Tmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-class JSI_EXPORT WEBGL_compressed_texture_etc1Impl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_etc1"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_compressed_texture_etc1"));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGB_ETC1_WEBGL"),
+                  v8::Number::New(isolate, GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG));
+
+        cache->WEBGL_compressed_texture_etc1Tmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_compressed_texture_etc1Impl *compressedTextureEtc1) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_compressed_texture_etc1Impl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WEBGL_compressed_texture_etc1);
+        auto ext = v8::External::New(isolate, compressedTextureEtc1);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_compressed_texture_etc1Impl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_compressed_texture_etc1Impl *>(ptr);
+    }
 };

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

@@ -4,15 +4,85 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
+class WEBGL_compressed_texture_etcImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_compressed_texture_etcTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-class JSI_EXPORT WEBGL_compressed_texture_etcImpl: public jsi::HostObject{
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_etc"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_R11_EAC"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_R11_EAC));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SIGNED_R11_EAC"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_SIGNED_R11_EAC));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RG11_EAC"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RG11_EAC));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SIGNED_RG11_EAC"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_SIGNED_RG11_EAC));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGB8_ETC2"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGB8_ETC2));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA8_ETC2_EAC"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGBA8_ETC2_EAC));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB8_ETC2"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_SRGB8_ETC2));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_compressed_texture_etc"));
+
+        cache->WEBGL_compressed_texture_etcTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_compressed_texture_etcImpl *compressedTextureEtc) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_compressed_texture_etcImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WEBGL_compressed_texture_etc);
+        auto ext = v8::External::New(isolate, compressedTextureEtc);
+        object->SetInternalField(0, ext);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "WEBGL_compressed_texture_etc"));
+        return scope.Escape(object);
+    }
+
+    static WEBGL_compressed_texture_etcImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_compressed_texture_etcImpl *>(ptr);
+    }
 };

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

@@ -4,15 +4,66 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
 
-class JSI_EXPORT WEBGL_compressed_texture_pvrtcImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+class WEBGL_compressed_texture_pvrtcImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_compressed_texture_pvrtcTmpl.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, "WEBGL_compressed_texture_pvrtc"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGB_PVRTC_4BPPV1_IMG"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGB_PVRTC_2BPPV1_IMG"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_compressed_texture_pvrtc"));
+
+        cache->WEBGL_compressed_texture_pvrtcTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_compressed_texture_pvrtcImpl *compressedTexturePvrtc) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_compressed_texture_pvrtcImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WEBGL_compressed_texture_pvrtc);
+        auto ext = v8::External::New(isolate, compressedTexturePvrtc);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_compressed_texture_pvrtcImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_compressed_texture_pvrtcImpl *>(ptr);
+    }
 };

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"
 
-using namespace facebook;
+class WEBGL_compressed_texture_s3tcImpl {
+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);
+        }
 
-class JSI_EXPORT WEBGL_compressed_texture_s3tcImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGB_S3TC_DXT1_EXT"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGB_S3TC_DXT1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_S3TC_DXT1_EXT"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGBA_S3TC_DXT1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_S3TC_DXT3_EXT"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_RGBA_S3TC_DXT3_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_RGBA_S3TC_DXT5_EXT"),
+                  v8::Number::New(isolate, (double) 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(isolate, object, NativeType::WEBGL_compressed_texture_s3tc);
+        auto ext = v8::External::New(isolate, textureS3Tc);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_compressed_texture_s3tcImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        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"
 
-using namespace facebook;
+class WEBGL_compressed_texture_s3tc_srgbImpl {
+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);
+        }
 
-class JSI_EXPORT WEBGL_compressed_texture_s3tc_srgbImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc_srgb"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB_S3TC_DXT1_EXT"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_SRGB_S3TC_DXT1_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"),
+                  v8::Number::New(isolate, (double) GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"),
+                  v8::Number::New(isolate, (double) 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(isolate, object, NativeType::WEBGL_compressed_texture_s3tc_srgb);
+        auto ext = v8::External::New(isolate, compressedTextureS3TcSrgb);
+        object->SetInternalField(0, ext);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc_srgb"));
+        return scope.Escape(object);
+    }
+
+    static WEBGL_compressed_texture_s3tc_srgbImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_compressed_texture_s3tc_srgbImpl *>(ptr);
+    }
 };