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

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

@@ -0,0 +1,388 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#pragma once
+#pragma process_pending_includes
+
+#include <vector>
+#include "Common.h"
+
+#include "WebGLRenderingContextBase.h"
+
+#include <cmath>
+#include "Helpers.h"
+
+#include "ImageAssetImpl.h"
+#include "ImageBitmapImpl.h"
+#include "RafImpl.h"
+
+#include "CanvasRenderingContext2DImpl.h"
+
+#include "WebGLBuffer.h"
+#include "WebGLFramebuffer.h"
+#include "WebGLProgram.h"
+#include "WebGLRenderbuffer.h"
+#include "WebGLShader.h"
+#include "WebGLTexture.h"
+#include "WebGLUniformLocation.h"
+#include "WebGLShaderPrecisionFormatImpl.h"
+#include "WebGLActiveInfoImpl.h"
+
+#include "extensions/EXT_blend_minmaxImpl.h"
+#include "extensions/EXT_color_buffer_half_floatImpl.h"
+#include "extensions/EXT_disjoint_timer_queryImpl.h"
+#include "extensions/EXT_sRGBImpl.h"
+#include "extensions/EXT_shader_texture_lodImpl.h"
+#include "extensions/EXT_texture_filter_anisotropicImpl.h"
+#include "extensions/OES_element_index_uintImpl.h"
+#include "extensions/OES_standard_derivativesImpl.h"
+#include "extensions/OES_texture_floatImpl.h"
+#include "extensions/OES_texture_float_linearImpl.h"
+#include "extensions/OES_texture_half_floatImpl.h"
+#include "extensions/OES_texture_half_float_linearImpl.h"
+#include "extensions/OES_vertex_array_objectImpl.h"
+#include "extensions/WEBGL_color_buffer_floatImpl.h"
+#include "extensions/WEBGL_compressed_texture_atcImpl.h"
+#include "extensions/WEBGL_compressed_texture_etcImpl.h"
+#include "extensions/WEBGL_compressed_texture_etc1Impl.h"
+#include "extensions/WEBGL_compressed_texture_pvrtcImpl.h"
+#include "extensions/WEBGL_compressed_texture_s3tcImpl.h"
+#include "extensions/WEBGL_compressed_texture_s3tc_srgbImpl.h"
+#include "extensions/WEBGL_depth_textureImpl.h"
+#include "extensions/WEBGL_lose_contextImpl.h"
+#include "extensions/ANGLE_instanced_arraysImpl.h"
+#include "extensions/WEBGL_draw_buffersImpl.h"
+#include "extensions/OES_fbo_render_mipmap.h"
+#include "gl.h"
+
+class WebGLRenderingContext : public WebGLRenderingContextBase {
+public:
+
+    WebGLRenderingContext(WebGLState* state);
+
+    WebGLRenderingContext(WebGLState* state, WebGLRenderingVersion version);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLRenderingContext *renderingContext) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLRenderingContext::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLRenderingContextBase);
+        auto ext = v8::External::New(isolate, renderingContext);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLRenderingContext *GetPointer(const v8::Local<v8::Object> &object);
+
+
+    static void SetConstants(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate> &tmpl);
+
+    static void
+    SetProps(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate> &tmpl);
+
+    static void SetMethods(v8::Isolate *isolate,
+                           const v8::Local<v8::ObjectTemplate> &tmpl);
+
+
+    v8::Local<v8::Value> GetParameterInternal(v8::Isolate *isolate, uint32_t pnameValue,
+                                              WebGLResult* result);
+
+    static void GetDrawingBufferWidth(v8::Local<v8::String> name,
+                                      const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetFlipY(v8::Local<v8::String> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetDrawingBufferHeight(v8::Local<v8::String> name,
+                                       const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void __Resized(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ActiveTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void AttachShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindAttribLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendColor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendEquationSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendEquation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendFuncSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendFunc(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BufferData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CheckFramebufferStatus(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearColor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearDepth(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearStencil(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Clear(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ColorMask(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Commit(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompileShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompressedTexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompressedTexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyTexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyTexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CullFace(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DepthFunc(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DepthMask(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DepthRange(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DetachShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DisableVertexAttribArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Disable(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawArrays(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawElements(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EnableVertexAttribArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Enable(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Finish(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Flush(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FramebufferRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FramebufferTexture2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FrontFace(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GenerateMipmap(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveAttrib(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetAttachedShaders(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetAttribLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetBufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetContextAttributes(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetError(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetExtension(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetFramebufferAttachmentParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetProgramInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetProgramParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetRenderbufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetShaderInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetShaderParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetShaderPrecisionFormat(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetShaderSource(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetSupportedExtensions(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetTexParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniformLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetVertexAttribOffset(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetVertexAttrib(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Hint(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsContextLost(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsEnabled(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void LineWidth(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void LinkProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PixelStorei(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PolygonOffset(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ReadPixels(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RenderbufferStorage(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SampleCoverage(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Scissor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ShaderSource(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void StencilFuncSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void StencilFunc(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void StencilMaskSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void StencilMask(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void StencilOpSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void StencilOp(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexParameterf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexParameteri(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1f(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1iv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1i(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform2f(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform2iv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform2i(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform3f(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform3iv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform3i(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform4f(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform4iv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform4i(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UseProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ValidateProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttrib1f(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttrib1fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttrib2f(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttrib2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttrib3f(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttrib3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttrib4f(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttrib4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribPointer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Viewport(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __ToDataURL(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __GetSupportedExtensions(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+};

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

@@ -0,0 +1,119 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#include "WebGLRenderingContextBase.h"
+
+WebGLRenderingContextBase::WebGLRenderingContextBase(WebGLState* state,
+                                                     WebGLRenderingVersion version)
+: state_(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, OnRafCallbackOnFrame);
+    this->SetRaf(
+                 std::make_shared<RafImpl>(
+                                           raf_callback,
+                                           raf_callback_ptr, raf));
+    
+    auto _raf = this->GetRaf();
+    
+    if (_raf != nullptr) {
+        canvas_native_raf_start(_raf->GetRaf());
+    }
+    
+}
+
+
+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::InvalidateStatePending);
+}
+
+void WebGLRenderingContextBase::Flush() {
+    auto state = this->GetInvalidateState() & (int) InvalidateState::InvalidateStatePending;
+    if (state == (int) InvalidateState::InvalidateStatePending) {
+        this->SetInvalidateState((int) InvalidateState::InvalidateStateInvalidating);
+        canvas_native_webgl_make_current(this->GetState());
+        canvas_native_webgl_swap_buffers(this->GetState());
+        this->SetInvalidateState((int) InvalidateState::InvalidateStateNone);
+    }
+}
+
+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());
+    }
+    canvas_native_raf_destroy(_raf->GetRaf());
+    this->raf_ = nullptr;
+    canvas_native_webgl_state_destroy(this->GetState());
+    this->state_ = nullptr;
+}

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

@@ -0,0 +1,69 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#pragma once
+#pragma process_pending_includes
+
+#include <vector>
+#include <cstdint>
+#include <memory>
+
+#include "Helpers.h"
+#include "RafImpl.h"
+#include "OnRafCallback.h"
+#include "Common.h"
+
+enum class WebGLRenderingVersion : uint8_t {
+    V1,
+    V2
+};
+
+class WebGLRenderingContextBase {
+public:
+    WebGLRenderingContextBase(WebGLState* state, WebGLRenderingVersion version);
+
+    static WebGLRenderingContextBase *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLRenderingContextBase *>(ptr);
+    }
+
+    ~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;
+
+    void StartRaf();
+
+    void StopRaf();
+
+private:
+    WebGLState* state_;
+
+    WebGLRenderingVersion version_;
+
+    int invalidateState_ = static_cast<int>(InvalidateState::InvalidateStateNone);
+
+    std::shared_ptr<RafImpl> raf_;
+};
+

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

@@ -0,0 +1,58 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#pragma once
+
+#include "Helpers.h"
+
+class WebGLShader {
+public:
+    WebGLShader(uint32_t shader) : shader_(shader) {}
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLShaderTmpl.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, "WebGLShader"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLShaderTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLShader *shader) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLShader::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLShader);
+        auto ext = v8::External::New(isolate, shader);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLShader *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLShader *>(ptr);
+    }
+
+    uint32_t GetShader() {
+        return this->shader_;
+    }
+
+private:
+    uint32_t shader_;
+};
+

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

@@ -0,0 +1,50 @@
+//
+// Created by Osei Fortune on 27/04/2022.
+//
+
+#include "WebGLShaderPrecisionFormatImpl.h"
+
+WebGLShaderPrecisionFormatImpl::WebGLShaderPrecisionFormatImpl(
+                                                               WebGLShaderPrecisionFormat* shader) : shader_(shader) {}
+
+
+void WebGLShaderPrecisionFormatImpl::GetRangeMin(v8::Local<v8::String> property,
+                                                 const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
+    }
+
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_range_min(
+            ptr->GetShaderPrecisionFormat()));
+}
+
+void WebGLShaderPrecisionFormatImpl::GetRangeMax(v8::Local<v8::String> property,
+                                                 const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
+    }
+
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_range_max(
+            ptr->GetShaderPrecisionFormat()));
+}
+
+
+void WebGLShaderPrecisionFormatImpl::GetPrecision(v8::Local<v8::String> property,
+                                                  const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
+    }
+
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_precision(
+            ptr->GetShaderPrecisionFormat()));
+}
+
+WebGLShaderPrecisionFormat* WebGLShaderPrecisionFormatImpl::GetShaderPrecisionFormat() {
+    return this->shader_;
+}