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

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

@@ -0,0 +1,93 @@
+//
+// 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->GetInternalField(0).As<v8::External>()->Value();
+    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(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLActiveInfo"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "name"),
+            GetName);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "size"),
+            GetSize);
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "type"),
+            GetType);
+
+    cache->WebGLActiveInfoTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void
+WebGLActiveInfoImpl::GetName(v8::Local<v8::String> 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());
+        info.GetReturnValue().Set(
+                ConvertToV8String(isolate, info_name));
+        canvas_native_string_destroy((char*)info_name);
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
+void
+WebGLActiveInfoImpl::GetSize(v8::Local<v8::String> name,
+                             const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    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::String> name,
+                             const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    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

@@ -0,0 +1,48 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+#include "Common.h"
+#include "Helpers.h"
+#include <vector>
+
+class WebGLActiveInfoImpl {
+public:
+    WebGLActiveInfoImpl(WebGLActiveInfo* info);
+    
+    ~WebGLActiveInfoImpl(){
+        canvas_native_webgl_active_info_destroy(this->info_);
+        this->info_ = nullptr;
+    }
+
+    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(isolate, object, NativeType::WebGLActiveInfo);
+        auto ext = v8::External::New(isolate, info);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static void
+    GetName(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void
+    GetSize(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void
+    GetType(v8::Local<v8::String> name, const v8::PropertyCallbackInfo<v8::Value> &info);
+
+private:
+    WebGLActiveInfo* info_;
+};
+

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

@@ -0,0 +1,59 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+
+#include "Common.h"
+#include "Caches.h"
+
+class WebGLBuffer {
+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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLBuffer"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        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(isolate, object, NativeType::WebGLBuffer);
+        auto ext = v8::External::New(isolate, buffer);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLBuffer *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLBuffer *>(ptr);
+    }
+
+    uint32_t GetBuffer() {
+        return this->buffer_;
+    }
+
+private:
+    uint32_t buffer_;
+};
+

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

@@ -0,0 +1,60 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+
+#include "Helpers.h"
+
+
+class WebGLFramebuffer {
+public:
+    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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLFramebuffer"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        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(isolate, object, NativeType::WebGLFramebuffer);
+        auto ext = v8::External::New(isolate, buffer);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLFramebuffer *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLFramebuffer *>(ptr);
+    }
+
+    uint32_t GetFrameBuffer() {
+        return this->framebuffer_;
+    }
+
+
+private:
+    uint32_t framebuffer_;
+};
+

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

@@ -0,0 +1,59 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma
+
+#include "Common.h"
+
+
+class WebGLProgram {
+public:
+    WebGLProgram(uint32_t program) : program_(program) {}
+
+    uint32_t GetProgram() {
+        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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLProgram"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        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(isolate, object, NativeType::WebGLProgram);
+        auto ext = v8::External::New(isolate, program);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLProgram *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLProgram *>(ptr);
+    }
+
+private:
+    uint32_t program_;
+};
+

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

@@ -0,0 +1,58 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+
+#include "Helpers.h"
+
+class WebGLRenderbuffer {
+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(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLRenderbuffer"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        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(isolate, object, NativeType::WebGLRenderbuffer);
+        auto ext = v8::External::New(isolate, buffer);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLRenderbuffer *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLRenderbuffer *>(ptr);
+    }
+
+    uint32_t GetRenderBuffer() {
+        return this->renderbuffer_;
+    }
+
+private:
+    uint32_t renderbuffer_;
+};
+