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

package/platforms/ios/src/cpp/webgl2/WebGLSampler.h

@@ -3,14 +3,53 @@
 //
 
 #pragma once
-#import <NativeScript/JSIRuntime.h>
 
-using namespace facebook;
+#include "Caches.h"
+#include "Common.h"
 
-class WebGLSampler : public jsi::HostObject {
+
+class WebGLSampler {
 public:
     WebGLSampler(uint32_t sampler) : sampler_(sampler) {}
 
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLSamplerTmpl.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, "WebGLSampler"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLSamplerTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLSampler *sampler) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLSampler::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLSampler);
+        auto ext = v8::External::New(isolate, sampler);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLSampler *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLSampler *>(ptr);
+    }
+
     uint32_t GetSampler() {
         return this->sampler_;
     }

package/platforms/ios/src/cpp/webgl2/WebGLSyncImpl.h

@@ -3,22 +3,55 @@
 //
 
 #pragma once
+#include "Common.h"
+#include "Caches.h"
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import <NativeScript/JSIRuntime.h>
+class WebGLSyncImpl {
+public:
+    WebGLSyncImpl(WebGLSync* sync) : sync_(sync) {}
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLSyncTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-class WebGLSyncImpl : public jsi::HostObject {
-public:
-    WebGLSyncImpl(rust::Box<WebGLSync> sync) : sync_(std::move(sync)) {}
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLSync"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLSyncTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLSyncImpl *sync) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLSyncImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLSync);
+        auto ext = v8::External::New(isolate, sync);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLSyncImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLSyncImpl *>(ptr);
+    }
 
-    WebGLSync &GetSync() {
-        return *this->sync_;
+    WebGLSync * GetSync() {
+        return this->sync_;
     }
 
 private:
-    rust::Box<WebGLSync> sync_;
+    WebGLSync* sync_;
 };

package/platforms/ios/src/cpp/webgl2/WebGLTransformFeedback.h

@@ -4,14 +4,52 @@
 
 #pragma once
 
-#import <NativeScript/JSIRuntime.h>
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
-
-class JSI_EXPORT WebGLTransformFeedback : public jsi::HostObject {
+class WebGLTransformFeedback {
 public:
     WebGLTransformFeedback(uint32_t feedback) : feedback_(feedback) {}
 
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLTransformFeedbackTmpl.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, "WebGLTransformFeedback"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLTransformFeedbackTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLTransformFeedback *feedback) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLTransformFeedback::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLTransformFeedback);
+        auto ext = v8::External::New(isolate, feedback);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLTransformFeedback *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLTransformFeedback *>(ptr);
+    }
+
     uint32_t GetFeedback() {
         return this->feedback_;
     }

package/platforms/ios/src/cpp/webgl2/WebGLVertexArrayObject.h

@@ -4,14 +4,53 @@
 
 #pragma once
 
-#import <NativeScript/JSIRuntime.h>
+#include "Caches.h"
+#include "Common.h"
+#include "Helpers.h"
 
-using namespace facebook;
-
-class JSI_EXPORT WebGLVertexArrayObject : public jsi::HostObject {
+class WebGLVertexArrayObject {
 public:
     WebGLVertexArrayObject(uint32_t vertexArrayObject) : vertexArrayObject_(vertexArrayObject) {}
 
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLVertexArrayObjectTmpl.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, "WebGLVertexArrayObject"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLVertexArrayObjectTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLVertexArrayObject *vertexArrayObject) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLVertexArrayObject::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLVertexArrayObject);
+        auto ext = v8::External::New(isolate, vertexArrayObject);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLVertexArrayObject *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLVertexArrayObject *>(ptr);
+    }
+
     uint32_t GetVertexArrayObject() {
         return this->vertexArrayObject_;
     }

package/platforms/ios/src/module.modulemap

@@ -1,4 +1,5 @@
 module CanvasModule {
     header "CanvasModule.h"
     export *
+   
 }