@nativescript/canvas 2.0.0-alpha.5 → 2.0.0-alpha.50

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

@@ -4,25 +4,39 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
+#include "Helpers.h"
 #include <vector>
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT ANGLE_instanced_arraysImpl : public jsi::HostObject {
+class ANGLE_instanced_arraysImpl: ObjectWrapperImpl {
 public:
-    ANGLE_instanced_arraysImpl(rust::Box<ANGLE_instanced_arrays> arrays);
+    ANGLE_instanced_arraysImpl(ANGLE_instanced_arrays *arrays);
+
+    ANGLE_instanced_arrays *GetArrays();
+
+    static ANGLE_instanced_arraysImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, ANGLE_instanced_arraysImpl *arrays) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = ANGLE_instanced_arraysImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::ANGLE_instanced_arrays);
+        object->SetAlignedPointerInInternalField(0, arrays);
+        arrays->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void DrawArraysInstancedANGLE(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void DrawElementsInstancedANGLE(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    ANGLE_instanced_arrays &GetArrays();
+    static void VertexAttribDivisorANGLE(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    rust::Box<ANGLE_instanced_arrays> arrays_;
+    ANGLE_instanced_arrays *arrays_;
 };
 

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

@@ -0,0 +1,35 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#include "EXT_blend_minmaxImpl.h"
+#include "Caches.h"
+#include "Helpers.h"
+
+v8::Local<v8::FunctionTemplate> EXT_blend_minmaxImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->EXT_blend_minmaxTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "EXT_blend_minmax"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->Set(ConvertToV8String(isolate, "MIN_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8007));
+
+    tmpl->Set(ConvertToV8String(isolate, "MAX_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8008));
+
+    tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+              ConvertToV8String(isolate, "EXT_blend_minmax"));
+
+    cache->EXT_blend_minmaxTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}

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

@@ -4,13 +4,33 @@
 
 #pragma once
 
-#import "NativeScript/JSIRuntime.h"
+#include "Common.h"
 #include <vector>
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+class EXT_blend_minmaxImpl: ObjectWrapperImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-using namespace facebook;
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, EXT_blend_minmaxImpl *minmax) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = EXT_blend_minmaxImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::EXT_blend_minmax);
+        object->SetAlignedPointerInInternalField(0, minmax);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "EXT_blend_minmax"));
+        minmax->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
 
-class JSI_EXPORT EXT_blend_minmaxImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
-
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static EXT_blend_minmaxImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<EXT_blend_minmaxImpl *>(ptr);
+    }
 };

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

@@ -0,0 +1,41 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#include "EXT_color_buffer_half_floatImpl.h"
+#include "Caches.h"
+#include "Helpers.h"
+
+v8::Local<v8::FunctionTemplate> EXT_color_buffer_half_floatImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->EXT_color_buffer_half_floatTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "EXT_color_buffer_half_float"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->Set(ConvertToV8String(isolate, "RGBA16F_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x881A));
+
+    tmpl->Set(ConvertToV8String(isolate, "RGB16F_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x881B));
+
+    tmpl->Set(ConvertToV8String(isolate, "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8211));
+
+    tmpl->Set(ConvertToV8String(isolate, "UNSIGNED_NORMALIZED_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8C17));
+
+    tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+              ConvertToV8String(isolate, "EXT_color_buffer_half_float"));
+
+    cache->EXT_color_buffer_half_floatTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}

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

@@ -4,14 +4,34 @@
 
 #pragma once
 
-#import "NativeScript/JSIRuntime.h"
+#include "Common.h"
 #include <vector>
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+class EXT_color_buffer_half_floatImpl: ObjectWrapperImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-using namespace facebook;
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, EXT_color_buffer_half_floatImpl *buffer) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = EXT_color_buffer_half_floatImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::EXT_color_buffer_half_float);
+        object->SetAlignedPointerInInternalField(0, buffer);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "EXT_color_buffer_half_float"));
+        buffer->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
 
-class JSI_EXPORT EXT_color_buffer_half_floatImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
-
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static EXT_color_buffer_half_floatImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<EXT_color_buffer_half_floatImpl *>(ptr);
+    }
 };
 

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

@@ -0,0 +1,306 @@
+//
+// 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(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "EXT_disjoint_timer_query"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->Set(ConvertToV8String(isolate, "QUERY_COUNTER_BITS_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8864));
+
+    tmpl->Set(ConvertToV8String(isolate, "CURRENT_QUERY_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8865));
+
+    tmpl->Set(ConvertToV8String(isolate, "QUERY_RESULT_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8866));
+
+    tmpl->Set(ConvertToV8String(isolate, "QUERY_RESULT_AVAILABLE_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8867));
+
+    tmpl->Set(ConvertToV8String(isolate, "TIME_ELAPSED_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x88BF));
+
+    tmpl->Set(ConvertToV8String(isolate, "TIMESTAMP_EXT"),
+              v8::Integer::NewFromUnsigned(isolate, 0x8E28));
+
+    tmpl->Set(ConvertToV8String(isolate, "GPU_DISJOINT_EXT"),
+              v8::Integer::NewFromUnsigned(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->GetAlignedPointerFromInternalField(0);
+    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 ret = canvas_native_webgl_ext_disjoint_timer_query_create_query_ext(
+            ptr->GetQuery());
+
+    auto object = new WebGLQuery(
+            ret);
+
+    auto value = WebGLQuery::NewInstance(isolate, object);
+    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];
+    auto type = GetNativeType( value);
+
+    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];
+    auto type = GetNativeType( value);
+
+    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];
+
+    auto target = targetValue->Uint32Value(context).ToChecked();
+    auto type = GetNativeType( queryValue);
+    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];
+    auto target = value->Uint32Value(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];
+
+    auto target = targetValue->Uint32Value(context).ToChecked();
+    auto type = GetNativeType( 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 = args[0]->Uint32Value(context).ToChecked();
+    auto pname = args[1]->Uint32Value(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 = args[1]->Uint32Value(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 = args[1]->Uint32Value(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

@@ -4,25 +4,59 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
-#include "webgl2/WebGLQuery.h"
+#include "Helpers.h"
+#include "Common.h"
+#include "WebGLQuery.h"
 #include <vector>
+#include "ObjectWrapperImpl.h"
+class EXT_disjoint_timer_queryImpl: ObjectWrapperImpl {
+public:
+    EXT_disjoint_timer_queryImpl(EXT_disjoint_timer_query *query);
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
+    ~EXT_disjoint_timer_queryImpl() {
+        canvas_native_webgl_EXT_disjoint_timer_query_destroy(this->GetQuery());
+        this->query_ = nullptr;
+    }
 
-class JSI_EXPORT EXT_disjoint_timer_queryImpl : public jsi::HostObject {
-public:
-    EXT_disjoint_timer_queryImpl(rust::Box<EXT_disjoint_timer_query> query);
+    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( object, NativeType::EXT_disjoint_timer_query);
+        object->SetAlignedPointerInInternalField(0, query);
+        object->Set(context, ConvertToV8String(isolate, "ext_name"),
+                    ConvertToV8String(isolate, "EXT_disjoint_timer_query"));
+        query->BindFinalizer(isolate, object);
+        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);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void GetQueryObjectExt(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void GetQueryParameterExt(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    EXT_disjoint_timer_query &GetQuery();
 
 private:
-    rust::Box<EXT_disjoint_timer_query> query_;
+    EXT_disjoint_timer_query *query_;
 };

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

@@ -4,15 +4,58 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import "NativeScript/JSIRuntime.h"
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Caches.h"
+#include "ObjectWrapperImpl.h"
+class EXT_sRGBImpl: ObjectWrapperImpl {
+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);
+        }
 
-using namespace facebook;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "EXT_sRGB"));
 
-class JSI_EXPORT EXT_sRGBImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+        tmpl->Set(ConvertToV8String(isolate, "SRGB_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_SRGB_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "SRGB_ALPHA_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_SRGB_ALPHA_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "SRGB8_ALPHA8_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_SRGB8_ALPHA8_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT"),
+                  v8::Integer::NewFromUnsigned(isolate, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"), ConvertToV8String(isolate, "EXT_sRGB"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        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( object, NativeType::EXT_sRGB);
+        object->SetAlignedPointerInInternalField(0, extSrgb);
+        extSrgb->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static EXT_sRGBImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<EXT_sRGBImpl *>(ptr);
+    }
 };