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

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

@@ -0,0 +1,56 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "gl.h"
+#include <vector>
+#include "Caches.h"
+#include "Common.h"
+#include "Helpers.h"
+
+class OES_standard_derivativesImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->OES_standard_derivativesTmpl.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_standard_derivatives"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "FRAGMENT_SHADER_DERIVATIVE_HINT_OES"),
+                  v8::Number::New(isolate, GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES));
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "OES_standard_derivatives"));
+        cache->OES_standard_derivativesTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, OES_standard_derivativesImpl *derivatives) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = OES_standard_derivativesImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::OES_standard_derivatives);
+        auto ext = v8::External::New(isolate, derivatives);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static OES_standard_derivativesImpl *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_standard_derivativesImpl *>(ptr);
+    }
+};

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

@@ -0,0 +1,53 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "Common.h"
+#include "Helpers.h"
+
+
+class OES_texture_floatImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->OES_texture_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, "OES_texture_float"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "OES_texture_float"));
+
+        cache->OES_texture_floatTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, OES_texture_floatImpl *texture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLShader::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::OES_texture_float);
+        auto ext = v8::External::New(isolate, texture);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static OES_texture_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<OES_texture_floatImpl *>(ptr);
+    }
+
+};

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

@@ -0,0 +1,52 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "Helpers.h"
+#include "Common.h"
+
+class  OES_texture_float_linearImpl {
+public:
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->OES_texture_float_linearTmpl.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_texture_float_linear"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"), ConvertToV8String(isolate, "OES_texture_float_linear"));
+
+        cache->OES_texture_float_linearTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, OES_texture_float_linearImpl *texture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = OES_texture_float_linearImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::OES_texture_float_linear);
+        auto ext = v8::External::New(isolate, texture);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static OES_texture_float_linearImpl *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_texture_float_linearImpl *>(ptr);
+    }
+
+};

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

@@ -0,0 +1,53 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "gl.h"
+#include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
+
+class OES_texture_half_floatImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->OES_texture_half_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, "OES_texture_half_float"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"), ConvertToV8String(isolate, "OES_texture_half_float"));
+        tmpl->Set(ConvertToV8String(isolate, "HALF_FLOAT_OES"), v8::Number::New(isolate, (double ) GL_HALF_FLOAT_OES));
+        cache->OES_texture_half_floatTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, OES_texture_half_floatImpl *texture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = OES_texture_half_floatImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::OES_texture_half_float);
+        auto ext = v8::External::New(isolate, texture);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static OES_texture_half_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<OES_texture_half_floatImpl *>(ptr);
+    }
+};

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

@@ -0,0 +1,54 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
+
+class OES_texture_half_float_linearImpl {
+public:
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->OES_texture_half_float_linearTmpl.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_texture_half_float_linear"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "OES_texture_half_float_linear"));
+
+        cache->OES_texture_half_float_linearTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, OES_texture_half_float_linearImpl *texture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = OES_texture_half_float_linearImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::OES_texture_half_float_linear);
+        auto ext = v8::External::New(isolate, texture);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static OES_texture_half_float_linearImpl *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_texture_half_float_linearImpl *>(ptr);
+    }
+};

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

@@ -0,0 +1,102 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#include "OES_vertex_array_objectImpl.h"
+
+
+OES_vertex_array_objectImpl::OES_vertex_array_objectImpl(OES_vertex_array_object* object)
+        : object_(object) {
+
+}
+
+void OES_vertex_array_objectImpl::CreateVertexArrayOES(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    OES_vertex_array_objectImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+    auto isolate = args.GetIsolate();
+
+    auto ret = canvas_native_webgl_oes_vertex_array_object_create_vertex_array_oes(
+            ptr->GetVertexArrayObject());
+    auto vertex = WebGLVertexArrayObject::NewInstance(isolate, new WebGLVertexArrayObject(
+            ret));
+
+    args.GetReturnValue().Set(vertex);
+}
+
+
+void OES_vertex_array_objectImpl::DeleteVertexArrayOES(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    OES_vertex_array_objectImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+
+    if (type == NativeType::WebGLVertexArrayObject) {
+        auto array_object = WebGLVertexArrayObject::GetPointer(value.As<v8::Object>());
+        if (array_object != nullptr) {
+            canvas_native_webgl_oes_vertex_array_object_delete_vertex_array_oes(
+                    array_object->GetVertexArrayObject(),
+                    ptr->GetVertexArrayObject()
+            );
+        }
+    }
+}
+
+void OES_vertex_array_objectImpl::IsVertexArrayOES(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    OES_vertex_array_objectImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().Set(false);
+        return;
+    }
+    auto isolate = args.GetIsolate();
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+
+    if (type == NativeType::WebGLVertexArrayObject) {
+        auto array_object = WebGLVertexArrayObject::GetPointer(value.As<v8::Object>());
+        if (array_object != nullptr) {
+            auto ret = canvas_native_webgl_oes_vertex_array_object_is_vertex_array_oes(
+                    array_object->GetVertexArrayObject(),
+                    ptr->GetVertexArrayObject()
+            );
+
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().Set(false);
+}
+
+
+void OES_vertex_array_objectImpl::BindVertexArrayOES(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    OES_vertex_array_objectImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+
+    if (type == NativeType::WebGLVertexArrayObject) {
+        auto array_object = WebGLVertexArrayObject::GetPointer(value.As<v8::Object>());
+        if (array_object != nullptr) {
+            canvas_native_webgl_oes_vertex_array_object_bind_vertex_array_oes(
+                    array_object->GetVertexArrayObject(),
+                    ptr->GetVertexArrayObject()
+            );
+        }
+    }
+}

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

@@ -0,0 +1,87 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "gl.h"
+#include "WebGLVertexArrayObject.h"
+#include "Helpers.h"
+#include <vector>
+
+class OES_vertex_array_objectImpl {
+public:
+    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"));
+
+        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;
+    }
+
+    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);
+    }
+
+    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:
+    OES_vertex_array_object* object_;
+};

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

@@ -0,0 +1,63 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#define once
+
+#include "gl.h"
+#include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
+
+class WEBGL_color_buffer_floatImpl {
+public:
+    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);
+    }
+
+    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

@@ -0,0 +1,61 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "gl.h"
+#include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
+
+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);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_atc"));
+
+        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

@@ -0,0 +1,59 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "gl.h"
+#include <vector>
+#include "Common.h"
+#include "Caches.h"
+#include "Helpers.h"
+
+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);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_etc1"));
+
+        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);
+    }
+};