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

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

@@ -0,0 +1,88 @@
+//
+// 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_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);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_etc"));
+
+        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

@@ -0,0 +1,69 @@
+//
+// 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_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);
+        }
+
+        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

@@ -0,0 +1,65 @@
+//
+// 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_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);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc"));
+
+        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

@@ -0,0 +1,72 @@
+//
+// 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 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);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_compressed_texture_s3tc_srgb"));
+
+        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);
+    }
+};
+

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

@@ -0,0 +1,59 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma
+
+#include "gl.h"
+#include <vector>
+#include "Helpers.h"
+#include "Caches.h"
+#include "Common.h"
+
+
+class WEBGL_depth_textureImpl {
+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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_depth_texture"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->Set(ConvertToV8String(isolate, "UNSIGNED_INT_24_8_WEBGL"), v8::Number::New(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(isolate, object, NativeType::WEBGL_depth_texture);
+        auto ext = v8::External::New(isolate, depthTexture);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_depth_textureImpl *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_depth_textureImpl *>(ptr);
+    }
+};

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

@@ -0,0 +1,43 @@
+//
+// 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) {
+
+}
+
+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();
+            if (!item->IsNumber()) {
+                // todo verify
+                buf.push_back(0);
+            } else {
+                buf.push_back(
+                        (uint32_t) item->NumberValue(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

@@ -0,0 +1,143 @@
+//
+// 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_draw_buffersImpl {
+public:
+    WEBGL_draw_buffersImpl(WEBGL_draw_buffers* buffers);
+    ~WEBGL_draw_buffersImpl() {
+    // todo
+    }
+
+    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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_draw_buffers"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "drawBuffersWEBGL"),
+                  v8::FunctionTemplate::New(isolate, &DrawBuffersWEBGL));
+
+        
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT0_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT0_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT1_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT2_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT2_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT3_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT3_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT4_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT4_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT5_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT5_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT6_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT6_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT7_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT7_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT8_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT8_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT9_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT9_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT10_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT10_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT11_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT11_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT12_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT12_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT13_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT13_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT14_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT14_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT15_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT15_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER0_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER0_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER1_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER2_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER2_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER3_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER3_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER4_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER4_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER5_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER5_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER6_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER6_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER7_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER7_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER8_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER8_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER9_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER9_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER10_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER10_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER11_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER11_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER12_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER12_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER13_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER13_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER14_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER14_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER15_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER15_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "MAX_COLOR_ATTACHMENTS_WEBGL"),
+                  v8::Number::New(isolate, GL_MAX_COLOR_ATTACHMENTS_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "MAX_DRAW_BUFFERS_WEBGL"),
+                  v8::Number::New(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(isolate, object, NativeType::WEBGL_draw_buffers);
+        auto ext = v8::External::New(isolate, buffers);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_draw_buffersImpl *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_draw_buffersImpl *>(ptr);
+    }
+
+    static void DrawBuffersWEBGL(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    WEBGL_draw_buffers* GetDrawBuffers() {
+        return this->buffers_;
+    }
+
+private:
+    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

@@ -0,0 +1,80 @@
+//
+// 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_lose_contextImpl {
+public:
+    WEBGL_lose_contextImpl(WEBGL_lose_context* context);
+    ~WEBGL_lose_contextImpl() {
+        canvas_native_webgl_WEBGL_lose_context_destroy(this->GetContext());
+        this->context_ = nullptr;
+    }
+
+    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);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WEBGL_lose_context"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        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"));
+
+        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(isolate, object, NativeType::WEBGL_lose_context);
+        auto ext = v8::External::New(isolate, element);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_lose_contextImpl *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_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_;
+    }
+
+
+private:
+    WEBGL_lose_context* context_;
+};