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

package/platforms/ios/src/cpp/webgl/WebGLActiveInfoImpl.cpp

@@ -0,0 +1,91 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#include "WebGLActiveInfoImpl.h"
+#include "Caches.h"
+#include "Helpers.h"
+
+WebGLActiveInfoImpl::WebGLActiveInfoImpl(WebGLActiveInfo* info) : info_(info) {}
+
+WebGLActiveInfoImpl *WebGLActiveInfoImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<WebGLActiveInfoImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> WebGLActiveInfoImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->WebGLActiveInfoTmpl.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, "WebGLActiveInfo"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "name"),
+            GetName);
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "size"),
+            GetSize);
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "type"),
+            GetType);
+
+    cache->WebGLActiveInfoTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void
+WebGLActiveInfoImpl::GetName(v8::Local<v8::Name> name,
+                             const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    if (ptr != nullptr) {
+        auto info_name = canvas_native_webgl_active_info_get_name(ptr->GetWebGLActiveInfo());
+        auto returnValue = new OneByteStringResource((char *)info_name);
+        auto ret = v8::String::NewExternalOneByte(isolate, returnValue);
+        info.GetReturnValue().Set(ret.ToLocalChecked());
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
+void
+WebGLActiveInfoImpl::GetSize(v8::Local<v8::Name> name,
+                             const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto size = canvas_native_webgl_active_info_get_size(ptr->GetWebGLActiveInfo());
+        info.GetReturnValue().Set(size);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+
+void
+WebGLActiveInfoImpl::GetType(v8::Local<v8::Name> name,
+                             const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto type = canvas_native_webgl_active_info_get_type(ptr->GetWebGLActiveInfo());
+        info.GetReturnValue().Set(type);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+
+WebGLActiveInfo* WebGLActiveInfoImpl::GetWebGLActiveInfo() {
+    return this->info_;
+}
+

package/platforms/ios/src/cpp/webgl/WebGLActiveInfoImpl.h

@@ -3,26 +3,46 @@
 //
 
 #pragma once
-
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
+#include "Common.h"
+#include "Helpers.h"
 #include <vector>
+#include "ObjectWrapperImpl.h"
+class WebGLActiveInfoImpl: ObjectWrapperImpl {
+public:
+    WebGLActiveInfoImpl(WebGLActiveInfo* info);
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
+    ~WebGLActiveInfoImpl(){
+        canvas_native_webgl_active_info_destroy(this->info_);
+        this->info_ = nullptr;
+    }
 
-class JSI_EXPORT WebGLActiveInfoImpl : public jsi::HostObject {
-public:
-    WebGLActiveInfoImpl(rust::Box<WebGLActiveInfo> info);
+    WebGLActiveInfo* GetWebGLActiveInfo();
+
+    static WebGLActiveInfoImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLActiveInfoImpl *info) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLActiveInfoImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLActiveInfo);
+        object->SetAlignedPointerInInternalField(0, info);
+        info->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static void
+    GetName(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void
+    GetSize(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    WebGLActiveInfo &GetWebGLActiveInfo();
+    static void
+    GetType(v8::Local<v8::Name> name, const v8::PropertyCallbackInfo<v8::Value> &info);
 
 private:
-    rust::Box<WebGLActiveInfo> info_;
+    WebGLActiveInfo* info_;
 };
 

package/platforms/ios/src/cpp/webgl/WebGLBuffer.h

@@ -4,16 +4,51 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
-
-using namespace facebook;
-
-class JSI_EXPORT WebGLBuffer : public jsi::HostObject {
+#include "Common.h"
+#include "Caches.h"
+#include "ObjectWrapperImpl.h"
+class WebGLBuffer: ObjectWrapperImpl {
 public:
     WebGLBuffer(uint32_t buffer) : buffer_(buffer) {}
 
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLBufferTmpl.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, "WebGLBuffer"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        cache->WebGLBufferTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLBuffer *buffer) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLBuffer::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLBuffer);
+        object->SetAlignedPointerInInternalField(0, buffer);
+        buffer->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGLBuffer *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLBuffer *>(ptr);
+    }
+
     uint32_t GetBuffer() {
         return this->buffer_;
     }

package/platforms/ios/src/cpp/webgl/WebGLFramebuffer.h

@@ -4,21 +4,57 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-
-class JSI_EXPORT WebGLFramebuffer: public jsi::HostObject {
+class WebGLFramebuffer: ObjectWrapperImpl {
 public:
-WebGLFramebuffer(uint32_t framebuffer) : framebuffer_(framebuffer) {}
+    WebGLFramebuffer(uint32_t framebuffer) : framebuffer_(framebuffer) {}
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLFramebufferTmpl.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, "WebGLFramebuffer"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        cache->WebGLFramebufferTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLFramebuffer *buffer) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLFramebuffer::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLFramebuffer);
+        object->SetAlignedPointerInInternalField(0, buffer);
+        buffer->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGLFramebuffer *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLFramebuffer *>(ptr);
+    }
+
+    uint32_t GetFrameBuffer() {
+        return this->framebuffer_;
+    }
 
-uint32_t GetFrameBuffer() {
-    return this->framebuffer_;
-}
 
 private:
-uint32_t framebuffer_;
+    uint32_t framebuffer_;
 };
 

package/platforms/ios/src/cpp/webgl/WebGLProgram.h

@@ -4,13 +4,10 @@
 
 #pragma
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
+#include "Common.h"
+#include "ObjectWrapperImpl.h"
 
-using namespace facebook;
-
-class WebGLProgram: public jsi::HostObject {
+class WebGLProgram:ObjectWrapperImpl  {
 public:
     WebGLProgram(uint32_t program) : program_(program) {}
 
@@ -18,6 +15,44 @@ public:
         return this->program_;
     }
 
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLProgramTmpl.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, "WebGLProgram"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        cache->WebGLProgramTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLProgram *program) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLProgram::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLProgram);
+        object->SetAlignedPointerInInternalField(0, program);
+        program->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGLProgram *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLProgram *>(ptr);
+    }
+
 private:
     uint32_t program_;
 };

package/platforms/ios/src/cpp/webgl/WebGLRenderbuffer.h

@@ -4,16 +4,50 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#include "canvas-cxx/src/lib.rs.h"
-#import "NativeScript/JSIRuntime.h"
-
-using namespace facebook;
-
-class JSI_EXPORT WebGLRenderbuffer : public jsi::HostObject {
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+class WebGLRenderbuffer: ObjectWrapperImpl {
 public:
     WebGLRenderbuffer(uint32_t renderbuffer) : renderbuffer_(renderbuffer) {}
 
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLRenderbufferTmpl.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, "WebGLRenderbuffer"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(2);
+
+        cache->WebGLRenderbufferTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLRenderbuffer *buffer) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLRenderbuffer::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType( object, NativeType::WebGLRenderbuffer);
+        object->SetAlignedPointerInInternalField(0, buffer);
+        buffer->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static WebGLRenderbuffer *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetAlignedPointerFromInternalField(0);
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLRenderbuffer *>(ptr);
+    }
+
     uint32_t GetRenderBuffer() {
         return this->renderbuffer_;
     }