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

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

@@ -4,15 +4,56 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
+class 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);
+        }
 
-class JSI_EXPORT EXT_texture_filter_anisotropicImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "EXT_texture_filter_anisotropic"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        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

@@ -4,15 +4,58 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
+class 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);
+        }
 
-class JSI_EXPORT OES_element_index_uintImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "OES_element_index_uint"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        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

@@ -4,27 +4,48 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include <NativeScript/JSIRuntime.h>
 
-using namespace facebook;
 
-class JSI_EXPORT OES_fbo_render_mipmapImpl : public jsi::HostObject {
+class OES_fbo_render_mipmapImpl {
 public:
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override {
-        std::vector<jsi::PropNameID> ret;
-        ret.emplace_back(
-                jsi::PropNameID::forUtf8(rt, std::string("ext_name")));
-        return ret;
+    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;
     }
 
-    jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
-        auto methodName = name.utf8(runtime);
+    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);
+    }
 
-        if (methodName == "ext_name") {
-            return jsi::String::createFromAscii(runtime, "OES_fbo_render_mipmap");
+    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 jsi::Value::undefined();
+        return static_cast<OES_fbo_render_mipmapImpl *>(ptr);
     }
 };

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

@@ -4,15 +4,53 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Caches.h"
+#include "Common.h"
+#include "Helpers.h"
 
-using namespace facebook;
+class 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);
+        }
 
-class JSI_EXPORT OES_standard_derivativesImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "OES_standard_derivatives"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        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

@@ -4,27 +4,50 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
+#include "Common.h"
+#include "Helpers.h"
 
-using namespace facebook;
 
-class JSI_EXPORT OES_texture_floatImpl : public jsi::HostObject {
+class OES_texture_floatImpl {
 public:
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override {
-        std::vector<jsi::PropNameID> ret;
-        ret.emplace_back(
-                jsi::PropNameID::forUtf8(rt, std::string("ext_name")));
-        return ret;
+    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;
     }
 
-    jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
-        auto methodName = name.utf8(runtime);
+    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);
+    }
 
-        if (methodName == "ext_name") {
-            return jsi::String::createFromAscii(runtime, "OES_texture_float");
+    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 jsi::Value::undefined();
+        return static_cast<OES_texture_floatImpl *>(ptr);
     }
+
 };

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

@@ -4,28 +4,49 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
+#include "Helpers.h"
+#include "Common.h"
 
-using namespace facebook;
+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);
+        }
 
-class JSI_EXPORT OES_texture_float_linearImpl : public jsi::HostObject {
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "OES_texture_float_linear"));
 
-public:
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override {
-        std::vector<jsi::PropNameID> ret;
-        ret.emplace_back(
-                jsi::PropNameID::forUtf8(rt, std::string("ext_name")));
-        return ret;
+        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;
     }
 
-    jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
-        auto methodName = name.utf8(runtime);
+    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);
+    }
 
-        if (methodName == "ext_name") {
-            return jsi::String::createFromAscii(runtime, "OES_texture_float_linear");
+    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 jsi::Value::undefined();
+        return static_cast<OES_texture_float_linearImpl *>(ptr);
     }
+
 };

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

@@ -4,15 +4,50 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
+class 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);
+        }
 
-class JSI_EXPORT OES_texture_half_floatImpl : public jsi::HostObject {
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "OES_texture_half_float"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        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

@@ -4,27 +4,51 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
-
-class JSI_EXPORT OES_texture_half_float_linearImpl : public jsi::HostObject {
+class OES_texture_half_float_linearImpl {
 public:
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override {
-        std::vector<jsi::PropNameID> ret;
-        ret.emplace_back(
-                jsi::PropNameID::forUtf8(rt, std::string("ext_name")));
-        return ret;
+
+    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;
     }
 
-    jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
-        auto methodName = name.utf8(runtime);
+    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);
+    }
 
-        if (methodName == "ext_name") {
-            return jsi::String::createFromAscii(runtime, "OES_texture_half_float_linear");
+    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 jsi::Value::undefined();
+        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()
+            );
+        }
+    }
+}