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

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

@@ -4,16 +4,56 @@
 
 #pragma
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Helpers.h"
+#include "Caches.h"
+#include "Common.h"
 
-using namespace facebook;
 
+class WEBGL_depth_textureImpl {
+public:
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_depth_textureTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-class JSI_EXPORT WEBGL_depth_textureImpl : 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, "WEBGL_depth_texture"));
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->Set(ConvertToV8String(isolate, "UNSIGNED_INT_24_8_WEBGL"), v8::Number::New(isolate, 0x84FA));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_depth_texture"));
+
+        cache->WEBGL_depth_textureTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_depth_textureImpl *depthTexture) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_depth_textureImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WEBGL_depth_texture);
+        auto ext = v8::External::New(isolate, depthTexture);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_depth_textureImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_depth_textureImpl *>(ptr);
+    }
 };

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

@@ -0,0 +1,43 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#include "WEBGL_draw_buffersImpl.h"
+
+WEBGL_draw_buffersImpl::WEBGL_draw_buffersImpl(WEBGL_draw_buffers* buffers) : buffers_(buffers) {
+
+}
+
+void WEBGL_draw_buffersImpl::DrawBuffersWEBGL(
+        const v8::FunctionCallbackInfo <v8::Value> &args) {
+    WEBGL_draw_buffersImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto value = args[0];
+    if (value->IsArray()) {
+        auto buffers = value.As<v8::Array>();
+        auto len = buffers->Length();
+        std::vector<uint32_t> buf;
+        buf.reserve(len);
+        for (int j = 0; j < len; ++j) {
+            auto item = buffers->Get(context, j).ToLocalChecked();
+            if (!item->IsNumber()) {
+                // todo verify
+                buf.push_back(0);
+            } else {
+                buf.push_back(
+                        (uint32_t) item->NumberValue(context).ToChecked());
+            }
+
+        }
+        
+        
+        canvas_native_webgl_draw_buffers_draw_buffers_webgl(buf.data(), buf.size(),ptr->GetDrawBuffers());
+
+    }
+
+}

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

@@ -4,28 +4,140 @@
 
 #pragma once
 
-#include "canvas-cxx/src/lib.rs.h"
-
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
 #include <vector>
+#include "Common.h"
+#include "Caches.h"
+#include "Helpers.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
-
-class JSI_EXPORT WEBGL_draw_buffersImpl : public jsi::HostObject {
+class WEBGL_draw_buffersImpl {
 public:
-    WEBGL_draw_buffersImpl(rust::Box<WEBGL_draw_buffers> buffers);
+    WEBGL_draw_buffersImpl(WEBGL_draw_buffers* buffers);
+    ~WEBGL_draw_buffersImpl() {
+    // todo
+    }
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_draw_buffersTmpl.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, "WEBGL_draw_buffers"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+        tmpl->Set(ConvertToV8String(isolate, "drawBuffersWEBGL"),
+                  v8::FunctionTemplate::New(isolate, &DrawBuffersWEBGL));
+
+        
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT0_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT0_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT1_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT2_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT2_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT3_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT3_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT4_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT4_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT5_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT5_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT6_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT6_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT7_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT7_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT8_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT8_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT9_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT9_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT10_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT10_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT11_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT11_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT12_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT12_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT13_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT13_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT14_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT14_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "COLOR_ATTACHMENT15_WEBGL"),
+                  v8::Number::New(isolate, GL_COLOR_ATTACHMENT15_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER0_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER0_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER1_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER1_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER2_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER2_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER3_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER3_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER4_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER4_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER5_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER5_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER6_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER6_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER7_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER7_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER8_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER8_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER9_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER9_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER10_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER10_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER11_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER11_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER12_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER12_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER13_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER13_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER14_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER14_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "DRAW_BUFFER15_WEBGL"),
+                  v8::Number::New(isolate, GL_DRAW_BUFFER15_EXT));
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        tmpl->Set(ConvertToV8String(isolate, "MAX_COLOR_ATTACHMENTS_WEBGL"),
+                  v8::Number::New(isolate, GL_MAX_COLOR_ATTACHMENTS_EXT));
+        tmpl->Set(ConvertToV8String(isolate, "MAX_DRAW_BUFFERS_WEBGL"),
+                  v8::Number::New(isolate, GL_MAX_DRAW_BUFFERS_EXT));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_draw_buffers"));
+
+        cache->WEBGL_draw_buffersTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_draw_buffersImpl *buffers) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_draw_buffersImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WEBGL_draw_buffers);
+        auto ext = v8::External::New(isolate, buffers);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WEBGL_draw_buffersImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_draw_buffersImpl *>(ptr);
+    }
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void DrawBuffersWEBGL(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    WEBGL_draw_buffers &GetDrawBuffers() {
-        return *this->buffers_;
+    WEBGL_draw_buffers* GetDrawBuffers() {
+        return this->buffers_;
     }
 
 private:
-    rust::Box<WEBGL_draw_buffers> buffers_;
+    WEBGL_draw_buffers* buffers_;
 };

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

@@ -0,0 +1,32 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#include "WEBGL_lose_contextImpl.h"
+
+
+WEBGL_lose_contextImpl::WEBGL_lose_contextImpl(WEBGL_lose_context* context) : context_(context){}
+
+
+void WEBGL_lose_contextImpl::LoseContext(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WEBGL_lose_contextImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    canvas_native_webgl_lose_context_lose_context(
+            ptr->GetContext());
+}
+
+
+void WEBGL_lose_contextImpl::RestoreContext(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WEBGL_lose_contextImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    canvas_native_webgl_lose_context_restore_context(
+            ptr->GetContext());
+}

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

@@ -4,28 +4,77 @@
 
 #pragma once
 
-#include "rust/cxx.h"
-#import <NativeScript/JSIRuntime.h>
 #include "gl.h"
-#include "canvas-cxx/src/lib.rs.h"
 #include <vector>
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
-using namespace org::nativescript::canvas;
 
-class JSI_EXPORT WEBGL_lose_contextImpl : public jsi::HostObject {
+class WEBGL_lose_contextImpl {
 public:
-    WEBGL_lose_contextImpl(rust::Box<WEBGL_lose_context> context);
+    WEBGL_lose_contextImpl(WEBGL_lose_context* context);
+    ~WEBGL_lose_contextImpl() {
+        canvas_native_webgl_WEBGL_lose_context_destroy(this->GetContext());
+        this->context_ = nullptr;
+    }
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WEBGL_lose_contextTmpl.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, "WEBGL_lose_context"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->Set(ConvertToV8String(isolate, "loseContext"),
+                  v8::FunctionTemplate::New(isolate, &LoseContext));
+        tmpl->Set(ConvertToV8String(isolate, "restoreContext"),
+                  v8::FunctionTemplate::New(isolate, &RestoreContext));
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WEBGL_lose_context"));
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+        cache->WEBGL_lose_contextTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WEBGL_lose_contextImpl *element) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WEBGL_lose_contextImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WEBGL_lose_context);
+        auto ext = v8::External::New(isolate, element);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static WEBGL_lose_contextImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WEBGL_lose_contextImpl *>(ptr);
+    }
+
+    static void LoseContext(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void RestoreContext(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    WEBGL_lose_context &GetContext() {
-        return *this->context_;
+    WEBGL_lose_context* GetContext() {
+        return this->context_;
     }
 
+
 private:
-    rust::Box<WEBGL_lose_context> context_;
+    WEBGL_lose_context* context_;
 };