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

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

@@ -0,0 +1,90 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#pragma once
+#pragma process_pending_includes
+
+#import <NativeScript/JSIRuntime.h>
+#include "rust/cxx.h"
+#include <vector>
+#include <cstdint>
+#include <memory>
+#include "canvas-cxx/src/lib.rs.h"
+
+#include "Helpers.h"
+#include "RafImpl.h"
+#include "OnRafCallback.h"
+#include "gl.h"
+
+enum class WebGLRenderingVersion : uint8_t {
+    V1,
+    V2
+};
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class WebGLRenderingContextBase : public jsi::HostObject {
+public:
+    WebGLRenderingContextBase(rust::Box<WebGLState> state, WebGLRenderingVersion version);
+
+    ~WebGLRenderingContextBase();
+
+    void UpdateInvalidateState();
+
+    int GetInvalidateState() const;
+
+    void SetInvalidateState(int state);
+
+    void SetInvalidateState(InvalidateState state);
+
+    void Flush();
+
+    static void Flush(intptr_t context);
+
+    WebGLState &GetState();
+
+    void SetRaf(std::shared_ptr<RafImpl> raf);
+
+    RafImpl *GetRaf();
+
+    WebGLRenderingVersion GetVersion() const;
+    
+    int GetDisplayFramebuffer(){
+        return displayFramebuffer_;
+    }
+
+    int GetDisplayRenderbuffer(){
+        return displayRenderbuffer_;
+    }
+    
+    void StartRaf();
+    void StopRaf();
+    
+    void UpdateBindings(){
+        auto displayFramebuffer = canvas_native_webgl_get_parameter(GL_FRAMEBUFFER_BINDING, *state_);
+        
+        auto displayRenderbuffer = canvas_native_webgl_get_parameter(GL_RENDERER, *state_);
+        
+        if(!canvas_native_webgl_result_get_is_none(*displayFramebuffer)){
+            displayFramebuffer_ = canvas_native_webgl_result_get_i32(*displayFramebuffer);
+        }
+        
+        if(!canvas_native_webgl_result_get_is_none(*displayRenderbuffer)){
+            displayRenderbuffer_ = canvas_native_webgl_result_get_i32(*displayRenderbuffer);
+        }
+    }
+
+private:
+    rust::Box<WebGLState> state_;
+
+    WebGLRenderingVersion version_;
+
+    int invalidateState_ = static_cast<int>(InvalidateState::NONE);
+
+    std::shared_ptr<RafImpl> raf_;
+    int displayFramebuffer_;
+    int displayRenderbuffer_;
+};
+

package/platforms/ios/src/cpp/webgl/WebGLRenderingContextBase.mm

@@ -0,0 +1,118 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#include "WebGLRenderingContextBase.h"
+
+WebGLRenderingContextBase::WebGLRenderingContextBase(rust::Box<WebGLState> state,
+                                                     WebGLRenderingVersion version)
+: state_(std::move(state)), version_(version) {
+    
+    
+    auto ctx_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(this));
+    auto raf_callback = new OnRafCallback(
+                                          ctx_ptr,
+                                          version == WebGLRenderingVersion::V2 ? 2 : 1);
+    auto raf_callback_ptr = reinterpret_cast<intptr_t>(reinterpret_cast<intptr_t *>(raf_callback));
+    auto raf = canvas_native_raf_create(
+                                        raf_callback_ptr);
+    this->SetRaf(
+                 std::make_shared<RafImpl>(
+                                           raf_callback,
+                                           raf_callback_ptr,
+                                           std::move(
+                                                     raf)));
+    
+    auto _raf = this->GetRaf();
+    
+    if (_raf != nullptr) {
+        canvas_native_raf_start(_raf->GetRaf());
+    }
+    
+    UpdateBindings();
+}
+
+
+void WebGLRenderingContextBase::StartRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_start(raf->GetRaf());
+        }
+    }
+}
+
+
+void WebGLRenderingContextBase::StopRaf() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_stop(raf->GetRaf());
+        }
+    }
+}
+
+void WebGLRenderingContextBase::UpdateInvalidateState() {
+    auto raf = this->GetRaf();
+    if (raf != nullptr) {
+        if (!canvas_native_raf_get_started(raf->GetRaf())) {
+            canvas_native_raf_start(raf->GetRaf());
+        }
+    }
+    auto state = this->GetInvalidateState();
+    this->SetInvalidateState(state | (int) InvalidateState::PENDING);
+}
+
+void WebGLRenderingContextBase::Flush() {
+    auto state = this->GetInvalidateState() & (int) InvalidateState::PENDING;
+    if (state == (int) InvalidateState::PENDING) {
+        this->SetInvalidateState((int) InvalidateState::INVALIDATING);
+        canvas_native_webgl_make_current(this->GetState());
+        canvas_native_webgl_swap_buffers(this->GetState());
+        this->SetInvalidateState((int) InvalidateState::NONE);
+    }
+}
+
+void WebGLRenderingContextBase::Flush(intptr_t context) {
+    auto ctx = reinterpret_cast<WebGLRenderingContextBase *>(reinterpret_cast<intptr_t *>(context));
+    if (ctx != nullptr) {
+        ctx->Flush();
+    }
+}
+
+WebGLState &WebGLRenderingContextBase::GetState() {
+    return *this->state_;
+}
+
+void WebGLRenderingContextBase::SetRaf(std::shared_ptr<RafImpl> raf) {
+    this->raf_ = std::move(raf);
+}
+
+RafImpl *WebGLRenderingContextBase::GetRaf() {
+    return this->raf_.get();
+}
+
+void WebGLRenderingContextBase::SetInvalidateState(InvalidateState state) {
+    this->invalidateState_ = (int) state;
+}
+
+
+void WebGLRenderingContextBase::SetInvalidateState(int state) {
+    this->invalidateState_ = state;
+}
+
+int WebGLRenderingContextBase::GetInvalidateState() const {
+    return this->invalidateState_;
+}
+
+WebGLRenderingVersion WebGLRenderingContextBase::GetVersion() const {
+    return this->version_;
+}
+
+WebGLRenderingContextBase::~WebGLRenderingContextBase() {
+    auto _raf = this->GetRaf();
+    if (_raf != nullptr) {
+        canvas_native_raf_stop(
+                                _raf->GetRaf());
+    }
+}

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

@@ -0,0 +1,24 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import <NativeScript/JSIRuntime.h>
+
+using namespace facebook;
+
+class JSI_EXPORT WebGLShader : public jsi::HostObject {
+public:
+    WebGLShader(uint32_t shader) : shader_(shader) {}
+
+    uint32_t GetShader() {
+        return this->shader_;
+    }
+
+private:
+    uint32_t shader_;
+};
+

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

@@ -0,0 +1,28 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import <NativeScript/JSIRuntime.h>
+#include <vector>
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class WebGLShaderPrecisionFormatImpl : public jsi::HostObject {
+public:
+    WebGLShaderPrecisionFormatImpl(rust::Box<WebGLShaderPrecisionFormat> shader);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    WebGLShaderPrecisionFormat &GetShaderPrecisionFormat();
+
+private:
+    rust::Box<WebGLShaderPrecisionFormat> shader_;
+};
+

package/platforms/ios/src/cpp/webgl/WebGLShaderPrecisionFormatImpl.mm

@@ -0,0 +1,40 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#include "WebGLShaderPrecisionFormatImpl.h"
+
+WebGLShaderPrecisionFormatImpl::WebGLShaderPrecisionFormatImpl(
+        rust::Box<WebGLShaderPrecisionFormat> shader) : shader_(
+        std::move(shader)) {}
+
+std::vector<jsi::PropNameID> WebGLShaderPrecisionFormatImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(3);
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("rangeMin")));
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("rangeMax")));
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("precision")));
+    return ret;
+}
+
+jsi::Value WebGLShaderPrecisionFormatImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+
+    if (methodName == "rangeMin") {
+        return {canvas_native_webgl_shader_precision_format_get_range_min(
+                this->GetShaderPrecisionFormat())};
+    } else if (methodName == "rangeMax") {
+        return {canvas_native_webgl_shader_precision_format_get_range_max(
+                this->GetShaderPrecisionFormat())};
+    } else if (methodName == "precision") {
+        return {canvas_native_webgl_shader_precision_format_get_precision(
+                this->GetShaderPrecisionFormat())};
+    }
+
+    return jsi::Value::undefined();
+}
+
+
+WebGLShaderPrecisionFormat &WebGLShaderPrecisionFormatImpl::GetShaderPrecisionFormat() {
+    return *this->shader_;
+}

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

@@ -0,0 +1,23 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import <NativeScript/JSIRuntime.h>
+
+using namespace facebook;
+
+class JSI_EXPORT WebGLTexture : public jsi::HostObject {
+public:
+    WebGLTexture(uint32_t texture) : texture_(texture) {}
+
+    uint32_t GetTexture() {
+        return this->texture_;
+    }
+
+private:
+    uint32_t texture_;
+};

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

@@ -0,0 +1,28 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import <NativeScript/JSIRuntime.h>
+
+using namespace facebook;
+
+
+class JSI_EXPORT WebGLUniformLocation
+
+        : public jsi::HostObject {
+public:
+    WebGLUniformLocation(int32_t
+                         uniformLocation) :
+            uniformLocation_(uniformLocation) {}
+
+    int32_t GetUniformLocation() {
+        return this->uniformLocation_;
+    }
+
+private:
+    int32_t uniformLocation_;
+};

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

@@ -0,0 +1,28 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import <NativeScript/JSIRuntime.h>
+#include <vector>
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class JSI_EXPORT ANGLE_instanced_arraysImpl : public jsi::HostObject {
+public:
+    ANGLE_instanced_arraysImpl(rust::Box<ANGLE_instanced_arrays> arrays);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    ANGLE_instanced_arrays &GetArrays();
+
+private:
+    rust::Box<ANGLE_instanced_arrays> arrays_;
+};
+

package/platforms/ios/src/cpp/webgl/extensions/ANGLE_instanced_arraysImpl.mm

@@ -0,0 +1,108 @@
+//
+// Created by Osei Fortune on 29/04/2022.
+//
+
+#include "ANGLE_instanced_arraysImpl.h"
+
+ANGLE_instanced_arraysImpl::ANGLE_instanced_arraysImpl(rust::Box<ANGLE_instanced_arrays> arrays)
+        : arrays_(
+        std::move(arrays)) {}
+
+std::vector<jsi::PropNameID> ANGLE_instanced_arraysImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(5);
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("drawArraysInstancedANGLE")));
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("drawElementsInstancedANGLE")));
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttribDivisorANGLE")));
+    ret.emplace_back(
+            jsi::PropNameID::forUtf8(rt, std::string("VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE")));
+    ret.emplace_back(
+            jsi::PropNameID::forUtf8(rt, std::string("ext_name")));
+    return ret;
+}
+
+jsi::Value ANGLE_instanced_arraysImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "ext_name") {
+        return jsi::String::createFromAscii(runtime, "ANGLE_instanced_arrays");
+    }
+    if (methodName == "VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE") {
+        return {0x88FE};
+    }
+    if (methodName == "drawArraysInstancedANGLE") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     4,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+                                                         auto mode = (uint32_t) arguments[0].asNumber();
+                                                         auto first = (int32_t) arguments[1].asNumber();
+                                                         auto count_ = (int32_t) arguments[2].asNumber();
+                                                         auto primcount = (int32_t) arguments[3].asNumber();
+
+                                                         canvas_native_webgl_angle_instanced_arrays_draw_arrays_instanced_angle(
+                                                                 mode,
+                                                                 first,
+                                                                 count_,
+                                                                 primcount,
+                                                                 this->GetArrays()
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+    } else if (methodName == "drawElementsInstancedANGLE") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     5,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+                                                         auto mode = (uint32_t) arguments[0].asNumber();
+                                                         auto count_ = (int32_t) arguments[1].asNumber();
+                                                         auto type = (uint32_t) arguments[2].asNumber();
+                                                         auto offset = (int32_t) arguments[3].asNumber();
+                                                         auto primcount = (int32_t) arguments[4].asNumber();
+                                                         canvas_native_webgl_angle_instanced_arrays_draw_elements_instanced_angle(
+                                                                 mode,
+                                                                 count_,
+                                                                 type,
+                                                                 offset,
+                                                                 primcount,
+                                                                 this->GetArrays()
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+    } else if (methodName == "vertexAttribDivisorANGLE") {
+        return jsi::Function::createFromHostFunction(runtime,
+                                                     jsi::PropNameID::forAscii(runtime, methodName),
+                                                     2,
+                                                     [this](jsi::Runtime &runtime,
+                                                            const jsi::Value &thisValue,
+                                                            const jsi::Value *arguments,
+                                                            size_t count) -> jsi::Value {
+
+                                                         auto index = (u_int32_t) arguments[0].asNumber();
+                                                         auto divisor = (u_int32_t) arguments[1].asNumber();
+                                                         canvas_native_webgl_angle_instanced_arrays_vertex_attrib_divisor_angle(
+                                                                 index,
+                                                                 divisor,
+                                                                 this->GetArrays()
+                                                         );
+
+                                                         return jsi::Value::undefined();
+                                                     }
+        );
+    }
+    return jsi::Value::undefined();
+}
+
+ANGLE_instanced_arrays &ANGLE_instanced_arraysImpl::GetArrays() {
+    return *this->arrays_;
+}

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

@@ -0,0 +1,16 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#pragma once
+
+#import <NativeScript/JSIRuntime.h>
+#include <vector>
+
+using namespace facebook;
+
+class JSI_EXPORT EXT_blend_minmaxImpl : public jsi::HostObject {
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+};

package/platforms/ios/src/cpp/webgl/extensions/EXT_blend_minmaxImpl.mm

@@ -0,0 +1,28 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#include "EXT_blend_minmaxImpl.h"
+
+std::vector<jsi::PropNameID> EXT_blend_minmaxImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(3);
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("MIN_EXT")));
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("MAX_EXT")));
+    ret.emplace_back(
+            jsi::PropNameID::forUtf8(rt, std::string("ext_name")));
+    return ret;
+}
+
+jsi::Value EXT_blend_minmaxImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+    if (methodName == "ext_name") {
+        return jsi::String::createFromAscii(runtime,"EXT_blend_minmax");
+    }
+    if (methodName == "MIN_EXT") {
+        return {0x8007};
+    } else if (methodName == "MAX_EXT") {
+        return {0x8008};
+    }
+    return jsi::Value::undefined();
+}

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

@@ -0,0 +1,17 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#pragma once
+
+#import <NativeScript/JSIRuntime.h>
+#include <vector>
+
+using namespace facebook;
+
+class JSI_EXPORT EXT_color_buffer_half_floatImpl : public jsi::HostObject {
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+};
+

package/platforms/ios/src/cpp/webgl/extensions/EXT_color_buffer_half_floatImpl.mm

@@ -0,0 +1,42 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#include "EXT_color_buffer_half_floatImpl.h"
+
+
+std::vector<jsi::PropNameID> EXT_color_buffer_half_floatImpl::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> ret;
+    ret.reserve(5);
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("RGBA16F_EXT")));
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("RGB16F_EXT")));
+    ret.emplace_back(
+            jsi::PropNameID::forUtf8(rt, std::string("FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT")));
+    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("UNSIGNED_NORMALIZED_EXT")));
+
+    ret.emplace_back(
+            jsi::PropNameID::forUtf8(rt, std::string("ext_name")));
+
+    return ret;
+}
+
+jsi::Value
+EXT_color_buffer_half_floatImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
+
+    if (methodName == "ext_name") {
+        return jsi::String::createFromAscii(runtime,"EXT_color_buffer_half_float");
+    }
+
+    if (methodName == "RGBA16F_EXT") {
+        return {0x881A};
+    } else if (methodName == "RGB16F_EXT") {
+        return {0x881B};
+    } else if (methodName == "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT") {
+        return {0x8211};
+    } else if (methodName == "UNSIGNED_NORMALIZED_EXT") {
+        return {0x8C17};
+    }
+
+    return jsi::Value::undefined();
+}

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

@@ -0,0 +1,28 @@
+//
+// Created by Osei Fortune on 28/04/2022.
+//
+
+#pragma once
+
+#include "rust/cxx.h"
+#include "canvas-cxx/src/lib.rs.h"
+#import <NativeScript/JSIRuntime.h>
+#include "webgl2/WebGLQuery.h"
+#include <vector>
+
+using namespace facebook;
+using namespace org::nativescript::canvas;
+
+class JSI_EXPORT EXT_disjoint_timer_queryImpl : public jsi::HostObject {
+public:
+    EXT_disjoint_timer_queryImpl(rust::Box<EXT_disjoint_timer_query> query);
+
+    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+
+    EXT_disjoint_timer_query &GetQuery();
+
+private:
+    rust::Box<EXT_disjoint_timer_query> query_;
+};