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

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

@@ -0,0 +1,323 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#include "EXT_disjoint_timer_queryImpl.h"
+#include "Caches.h"
+
+EXT_disjoint_timer_queryImpl::EXT_disjoint_timer_queryImpl(
+                                                           EXT_disjoint_timer_query* query) : query_(query) {}
+
+
+v8::Local<v8::FunctionTemplate> EXT_disjoint_timer_queryImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->EXT_disjoint_timer_queryTmpl.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, "EXT_disjoint_timer_query"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+
+    tmpl->Set(ConvertToV8String(isolate, "QUERY_COUNTER_BITS_EXT"),
+              v8::Number::New(isolate, 0x8864));
+
+    tmpl->Set(ConvertToV8String(isolate, "CURRENT_QUERY_EXT"),
+              v8::Number::New(isolate, 0x8865));
+
+    tmpl->Set(ConvertToV8String(isolate, "QUERY_RESULT_EXT"),
+              v8::Number::New(isolate, 0x8866));
+
+    tmpl->Set(ConvertToV8String(isolate, "QUERY_RESULT_AVAILABLE_EXT"),
+              v8::Number::New(isolate, 0x8867));
+
+    tmpl->Set(ConvertToV8String(isolate, "TIME_ELAPSED_EXT"),
+              v8::Number::New(isolate, 0x88BF));
+
+    tmpl->Set(ConvertToV8String(isolate, "TIMESTAMP_EXT"),
+              v8::Number::New(isolate, 0x8E28));
+
+    tmpl->Set(ConvertToV8String(isolate, "GPU_DISJOINT_EXT"),
+              v8::Number::New(isolate, 0x8FBB));
+
+
+    tmpl->Set(ConvertToV8String(isolate, "createQueryExt"),
+              v8::FunctionTemplate::New(isolate, &CreateQueryExt));
+    tmpl->Set(ConvertToV8String(isolate, "deleteQueryExt"),
+              v8::FunctionTemplate::New(isolate, &DeleteQueryExt));
+    tmpl->Set(ConvertToV8String(isolate, "isQueryExt"),
+              v8::FunctionTemplate::New(isolate, &IsQueryExt));
+    tmpl->Set(ConvertToV8String(isolate, "beginQueryExt"),
+              v8::FunctionTemplate::New(isolate, &BeginQueryExt));
+    tmpl->Set(ConvertToV8String(isolate, "endQueryExt"),
+              v8::FunctionTemplate::New(isolate, &EndQueryExt));
+    tmpl->Set(ConvertToV8String(isolate, "queryCounterExt"),
+              v8::FunctionTemplate::New(isolate, &QueryCounterExt));
+    tmpl->Set(ConvertToV8String(isolate, "getQueryExt"),
+              v8::FunctionTemplate::New(isolate, &GetQueryExt));
+    tmpl->Set(ConvertToV8String(isolate, "getQueryObjectExt"),
+              v8::FunctionTemplate::New(isolate, &GetQueryObjectExt));
+    tmpl->Set(ConvertToV8String(isolate, "getQueryParameterExt"),
+              v8::FunctionTemplate::New(isolate, &GetQueryParameterExt));
+
+    tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+              ConvertToV8String(isolate, "EXT_disjoint_timer_query"));
+
+    cache->EXT_disjoint_timer_queryTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+EXT_disjoint_timer_queryImpl *
+EXT_disjoint_timer_queryImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<EXT_disjoint_timer_queryImpl *>(ptr);
+}
+
+void EXT_disjoint_timer_queryImpl::CreateQueryExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto ret = canvas_native_webgl_ext_disjoint_timer_query_create_query_ext(
+            ptr->GetQuery());
+
+    auto object = new WebGLQuery(
+            ret);
+
+    auto value = WebGLQuery::GetCtor(isolate)->GetFunction(context).ToLocalChecked()->NewInstance(
+            context).ToLocalChecked();
+    value->SetInternalField(0, v8::External::New(isolate, object));
+    SetNativeType(isolate, value, NativeType::WebGLQuery);
+    args.GetReturnValue().Set(value);
+}
+
+void EXT_disjoint_timer_queryImpl::DeleteQueryExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto value = args[0];
+    if (value->IsObject()) {
+        auto type = GetNativeType(isolate, value.As<v8::Object>());
+
+        if (type == NativeType::WebGLQuery) {
+            auto query = WebGLQuery::GetPointer(value.As<v8::Object>());
+            if (query ==
+                nullptr) { return; }
+            canvas_native_webgl_ext_disjoint_timer_query_delete_query_ext(
+                    query->GetQuery(),
+                    ptr->GetQuery());
+        }
+
+    }
+}
+
+void EXT_disjoint_timer_queryImpl::IsQueryExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto value = args[0];
+    if (value->IsObject()) {
+        auto type = GetNativeType(isolate, value.As<v8::Object>());
+
+        if (type == NativeType::WebGLQuery) {
+            auto query = WebGLQuery::GetPointer(value.As<v8::Object>());
+            if (query != nullptr) {
+                auto ret = canvas_native_webgl_ext_disjoint_timer_query_is_query_ext(
+                        query->GetQuery(),
+                        ptr->GetQuery());
+
+                args.GetReturnValue().Set(ret);
+            }
+        }
+
+    }
+    args.GetReturnValue().Set(false);
+}
+
+
+void EXT_disjoint_timer_queryImpl::BeginQueryExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto targetValue = args[0];
+    auto queryValue = args[1];
+
+    if (targetValue->IsNumber() &&
+        queryValue->IsObject()) {
+        auto target = (uint32_t) targetValue->NumberValue(context).ToChecked();
+        auto type = GetNativeType(isolate, queryValue.As<v8::Object>());
+        if (type == NativeType::WebGLQuery) {
+            auto query = WebGLQuery::GetPointer(queryValue.As<v8::Object>());
+
+            canvas_native_webgl_ext_disjoint_timer_query_begin_query_ext(
+                    target,
+                    query->GetQuery(),
+                    ptr->GetQuery()
+            );
+        }
+    }
+}
+
+void EXT_disjoint_timer_queryImpl::EndQueryExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto value = args[0];
+    if (value->IsNumber()) {
+        auto target = (uint32_t) value->NumberValue(context).ToChecked();
+        canvas_native_webgl_ext_disjoint_timer_query_end_query_ext(
+                target,
+                ptr->GetQuery()
+        );
+    }
+}
+
+void EXT_disjoint_timer_queryImpl::QueryCounterExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto queryValue = args[0];
+    auto targetValue = args[1];
+
+    if (targetValue->IsNumber() &&
+        queryValue->IsObject()) {
+        auto target = (uint32_t) targetValue->NumberValue(context).ToChecked();
+        auto type = GetNativeType(isolate, queryValue.As<v8::Object>());
+        if (type == NativeType::WebGLQuery) {
+            auto query = WebGLQuery::GetPointer(queryValue.As<v8::Object>());
+
+            canvas_native_webgl_ext_disjoint_timer_query_query_counter_ext(
+                    query->GetQuery(),
+                    target,
+                    ptr->GetQuery()
+            );
+        }
+    }
+}
+
+void EXT_disjoint_timer_queryImpl::GetQueryExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
+    auto ret = canvas_native_webgl_ext_disjoint_timer_query_get_query_ext(
+            target,
+            pname,
+            ptr->GetQuery()
+    );
+
+    args.GetReturnValue().Set(ret);
+
+}
+
+void EXT_disjoint_timer_queryImpl::GetQueryObjectExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto query = WebGLQuery::GetPointer(args[0].As<v8::Object>());
+    auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
+
+    auto ret = canvas_native_webgl_ext_disjoint_timer_query_get_query_object_ext(
+            query->GetQuery(),
+            pname,
+            ptr->GetQuery()
+    );
+    
+
+    // GL_QUERY_RESULT_AVAILABLE_EXT
+    if (pname == 0x8867) {
+        args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
+                ret));
+        canvas_native_webgl_WebGLResult_destroy(ret);
+        return;
+    }
+
+
+    args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+            ret));
+    
+    canvas_native_webgl_WebGLResult_destroy(ret);
+}
+
+
+void EXT_disjoint_timer_queryImpl::GetQueryParameterExt(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    EXT_disjoint_timer_queryImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto query = WebGLQuery::GetPointer(args[0].As<v8::Object>());
+    auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
+
+    auto ret = canvas_native_webgl_ext_disjoint_timer_query_get_query_object_ext(
+            query->GetQuery(),
+            pname,
+            ptr->GetQuery()
+    );
+
+    // GL_QUERY_RESULT_AVAILABLE_EXT
+    if (pname == 0x8867) {
+        args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
+                ret));
+        canvas_native_webgl_WebGLResult_destroy(ret);
+        return;
+    }
+
+    args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+            ret));
+    canvas_native_webgl_WebGLResult_destroy(ret);
+}
+
+
+EXT_disjoint_timer_query* EXT_disjoint_timer_queryImpl::GetQuery() {
+    return this->query_;
+}

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

@@ -0,0 +1,62 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#pragma once
+
+#include "Helpers.h"
+#include "Common.h"
+#include "WebGLQuery.h"
+#include <vector>
+
+class EXT_disjoint_timer_queryImpl {
+public:
+    EXT_disjoint_timer_queryImpl(EXT_disjoint_timer_query* query);
+    
+    ~EXT_disjoint_timer_queryImpl(){
+        canvas_native_webgl_EXT_disjoint_timer_query_destroy(this->GetQuery());
+        this->query_ = nullptr;
+    }
+
+    EXT_disjoint_timer_query* GetQuery();
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, EXT_disjoint_timer_queryImpl *query) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = EXT_disjoint_timer_queryImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::EXT_disjoint_timer_query);
+        auto ext = v8::External::New(isolate, query);
+        object->SetInternalField(0, ext);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "EXT_disjoint_timer_query"));
+        return scope.Escape(object);
+    }
+
+    static EXT_disjoint_timer_queryImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static void CreateQueryExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteQueryExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsQueryExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BeginQueryExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EndQueryExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void QueryCounterExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQueryExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQueryObjectExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQueryParameterExt(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+private:
+    EXT_disjoint_timer_query* query_;
+};

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

@@ -0,0 +1,61 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "gl.h"
+#include <vector>
+#include "Helpers.h"
+#include "Caches.h"
+
+class EXT_sRGBImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->EXT_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, "EXT_sRGB"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "SRGB_EXT"),
+                  v8::Number::New(isolate, (double) GL_SRGB_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "SRGB_ALPHA_EXT"),
+                  v8::Number::New(isolate, (double) GL_SRGB_ALPHA_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "SRGB8_ALPHA8_EXT"),
+                  v8::Number::New(isolate, (double) GL_SRGB8_ALPHA8_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT"),
+                  v8::Number::New(isolate, (double) GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"), ConvertToV8String(isolate, "EXT_sRGB"));
+
+        cache->EXT_sRGBTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, EXT_sRGBImpl *extSrgb) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = EXT_sRGBImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::EXT_sRGB);
+        auto ext = v8::External::New(isolate, extSrgb);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static EXT_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<EXT_sRGBImpl *>(ptr);
+    }
+};

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

@@ -0,0 +1,51 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "Caches.h"
+#include "Common.h"
+
+class EXT_shader_texture_lodImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->EXT_shader_texture_lodTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "EXT_shader_texture_lod"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "EXT_shader_texture_lod"));
+
+        cache->EXT_shader_texture_lodTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, EXT_shader_texture_lodImpl *texture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = EXT_shader_texture_lodImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::EXT_shader_texture_lod);
+        auto ext = v8::External::New(isolate, texture);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static EXT_shader_texture_lodImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<EXT_shader_texture_lodImpl *>(ptr);
+    }
+};

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

@@ -0,0 +1,59 @@
+//
+// 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 EXT_texture_filter_anisotropicImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->EXT_texture_filter_anisotropicTmpl.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, "EXT_texture_filter_anisotropic"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "MAX_TEXTURE_MAX_ANISOTROPY_EXT"),
+                  v8::Number::New(isolate, (double) GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "TEXTURE_MAX_ANISOTROPY_EXT"),
+                  v8::Number::New(isolate, (double) GL_TEXTURE_MAX_ANISOTROPY_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "EXT_texture_filter_anisotropic"));
+
+        cache->EXT_texture_filter_anisotropicTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, EXT_texture_filter_anisotropicImpl *filterAnisotropic) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = EXT_texture_filter_anisotropicImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::EXT_texture_filter_anisotropic);
+        auto ext = v8::External::New(isolate, filterAnisotropic);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static EXT_texture_filter_anisotropicImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<EXT_texture_filter_anisotropicImpl *>(ptr);
+    }
+};

package/platforms/ios/src/cpp/webgl/extensions/OES_element_index_uintImpl.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 OES_element_index_uintImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->OES_element_index_uintTmpl.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_element_index_uint"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->Set(ConvertToV8String(isolate, "UNSIGNED_INT"),
+                  v8::Number::New(isolate, (double) GL_UNSIGNED_INT));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "OES_element_index_uint"));
+
+        cache->OES_element_index_uintTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, OES_element_index_uintImpl *element) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = OES_element_index_uintImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::OES_element_index_uint);
+        auto ext = v8::External::New(isolate, element);
+        object->SetInternalField(0, ext);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "OES_element_index_uint"));
+        return scope.Escape(object);
+    }
+
+    static OES_element_index_uintImpl *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_element_index_uintImpl *>(ptr);
+    }
+};

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

@@ -0,0 +1,51 @@
+//
+// Created by Osei Fortune on 02/05/2022.
+//
+
+#pragma once
+
+
+
+class OES_fbo_render_mipmapImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->OES_fbo_render_mipmapTmpl.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_fbo_render_mipmap"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->OES_fbo_render_mipmapTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, OES_fbo_render_mipmapImpl *texture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = OES_fbo_render_mipmapImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::OES_fbo_render_mipmap);
+        auto ext = v8::External::New(isolate, texture);
+        object->SetInternalField(0, ext);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "OES_fbo_render_mipmap"));
+        return scope.Escape(object);
+    }
+
+    static OES_fbo_render_mipmapImpl *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_fbo_render_mipmapImpl *>(ptr);
+    }
+};