@nativescript/canvas 2.0.0-webgpu.2 → 2.0.0-webgpu.4

package/platforms/ios/src/cpp/PromiseCallback.h

@@ -0,0 +1,198 @@
+//
+// Created by Osei Fortune on 05/08/2024.
+//
+
+#pragma once
+
+#include "Common.h"
+#include <thread>
+
+#ifdef __ANDROID__
+
+#include <android/looper.h>
+#include <cassert>
+
+#endif
+
+#ifdef __APPLE__
+#include "NSOperationQueueWrapper.h"
+#endif
+
+
+#include <unistd.h>
+#include <fcntl.h>
+
+typedef void(*CompleteCallback)(bool success, void *data);
+
+#ifdef __APPLE__
+struct PromiseCallback {
+    struct Inner {
+        NSOperationQueueWrapper* current_queue = nullptr;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Promise::Resolver> callback_;
+        v8::Persistent<v8::Value> error_;
+        CompleteCallback completeCallback_;
+        CompleteCallback completeCallbackWrapper_;
+        bool isPrepared_ = false;
+        void* data;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Promise::Resolver>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+            this->completeCallbackWrapper_ = [](bool success, void *data){
+                if(data != nullptr){
+                    auto* callback = static_cast<PromiseCallback*>(data);
+                    auto inner = callback->inner_.get();
+                    if(inner == nullptr || inner->current_queue != nullptr){
+                        return;
+                    }
+
+                    inner->current_queue->addOperation([success, data, inner, callback](){
+                        inner->completeCallback_(success, data);
+                     //   delete callback;
+                    });
+                }
+            };
+        }
+
+        void prepare(){
+            current_queue = new NSOperationQueueWrapper(true);
+            isPrepared_ = true;
+        }
+
+        void execute(bool complete, PromiseCallback* callback){
+           completeCallbackWrapper_(complete, callback);
+        }
+
+        ~Inner(){
+            callback_.Reset();
+            error_.Reset();
+        }
+    };
+
+    std::shared_ptr<Inner> inner_;
+
+    void prepare(){
+       auto inner = this->inner_.get();
+       if(inner == nullptr){return;}
+        inner->prepare();
+    }
+
+        void execute(bool complete) {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete, this);
+    }
+
+    explicit PromiseCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+    PromiseCallback(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+                    CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {}
+};
+#endif
+
+#ifdef __ANDROID__
+
+struct PromiseCallback {
+    struct Inner {
+        int fd_[2];
+        ALooper *looper_ = nullptr;
+        v8::Isolate *isolate_;
+        v8::Persistent<v8::Promise::Resolver> callback_;
+        void *data = nullptr;
+        CompleteCallback completeCallback_;
+        bool isPrepared_ = false;
+
+        Inner(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+              CompleteCallback completeCallback) : isolate_(isolate),
+                                                   callback_(v8::Persistent<v8::Promise::Resolver>(
+                                                           isolate,
+                                                           callback)) {
+            this->completeCallback_ = completeCallback;
+        }
+
+        void prepare() {
+            // release previous looper
+            if (isPrepared_) {
+                ALooper_removeFd(looper_, fd_[0]);
+                close(fd_[0]);
+                fd_[0] = -1;
+                fd_[1] = -1;
+                ALooper_release(looper_);
+            }
+
+            auto res = pipe(fd_);
+            assert(res != -1);
+            res = fcntl(fd_[1], F_SETFL, O_NONBLOCK);
+            assert(res != -1);
+            looper_ = ALooper_prepare(0);
+            ALooper_acquire(looper_);
+
+            isPrepared_ = true;
+        }
+
+        void execute(bool complete) const {
+            if (!isPrepared_) { return; }
+            write(fd_[1],
+                  &complete,
+                  sizeof(bool));
+        }
+
+
+        ~Inner() {
+            if (!isPrepared_) {
+                return;
+            }
+            ALooper_removeFd(looper_, fd_[0]);
+            close(fd_[0]);
+            ALooper_release(looper_);
+            callback_.Reset();
+        }
+    };
+
+    void prepare() const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->prepare();
+        auto looper = inner->looper_;
+        auto fd = inner->fd_[0];
+        auto data = new PromiseCallback(this->inner_);
+        ALooper_addFd(looper,
+                      fd,
+                      ALOOPER_POLL_CALLBACK,
+                      ALOOPER_EVENT_INPUT,
+                      [](int fd, int events,
+                         void *data) {
+                          auto cb = static_cast<PromiseCallback *>(data);
+                          bool done = false;
+                          read(fd, &done,
+                               sizeof(bool));
+                          cb->inner_->completeCallback_(done, data);
+                          return 0;
+                      }, (void *) data);
+
+        ALooper_wake(looper);
+        inner->isPrepared_ = true;
+    }
+
+    void execute(bool complete) const {
+        auto inner = this->inner_.get();
+        if (inner == nullptr) { return; }
+        inner->execute(complete);
+    }
+
+    std::shared_ptr<Inner> inner_;
+
+    explicit PromiseCallback(std::shared_ptr<Inner> inner) : inner_(std::move(inner)) {}
+
+    PromiseCallback(v8::Isolate *isolate, v8::Local<v8::Promise::Resolver> callback,
+                    CompleteCallback completeCallback) : inner_(
+            std::make_shared<Inner>(isolate, callback, completeCallback)) {}
+
+};
+
+#endif

package/platforms/ios/src/cpp/canvas2d/CanvasGradient.h

@@ -3,21 +3,22 @@
 //
 
 #pragma once
+
 #include <vector>
 #include "Common.h"
 #include "Helpers.h"
 #include "ObjectWrapperImpl.h"
 
-class CanvasGradient: ObjectWrapperImpl {
+class CanvasGradient : ObjectWrapperImpl {
 public:
-    explicit CanvasGradient(PaintStyle*style);
+    explicit CanvasGradient(PaintStyle *style);
 
-    ~CanvasGradient(){
+    ~CanvasGradient() {
         canvas_native_paint_style_release(this->GetPaintStyle());
         this->style_ = nullptr;
     }
 
-    PaintStyle * GetPaintStyle();
+    PaintStyle *GetPaintStyle();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -30,7 +31,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = CanvasGradient::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::CanvasGradient);
+        SetNativeType(gradient, NativeType::CanvasGradient);
         object->SetAlignedPointerInInternalField(0, gradient);
         gradient->BindFinalizer(isolate, object);
         return scope.Escape(object);
@@ -39,6 +40,6 @@ public:
     static void AddColorStop(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 private:
-    PaintStyle* style_;
+    PaintStyle *style_;
 };
 

package/platforms/ios/src/cpp/canvas2d/CanvasPattern.cpp

@@ -17,7 +17,7 @@ void CanvasPattern::Init(const v8::Local<v8::Object> &canvasModule, v8::Isolate
     auto context = isolate->GetCurrentContext();
     auto func = ctor->GetFunction(context).ToLocalChecked();
 
-    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasPattern"), func);
+    canvasModule->Set(context, ConvertToV8String(isolate, "CanvasPattern"), func).FromJust();
 }
 
 v8::CFunction CanvasPattern::fast_set_transform_(

package/platforms/ios/src/cpp/canvas2d/CanvasPattern.h

@@ -30,7 +30,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = CanvasPattern::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::CanvasPattern);
+        SetNativeType(pattern, NativeType::CanvasPattern);
         object->SetAlignedPointerInInternalField(0, pattern);
         pattern->BindFinalizer(isolate, object);
         return scope.Escape(object);

package/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.cpp

@@ -1609,7 +1609,7 @@ CanvasRenderingContext2DImpl::CreateImageData(const v8::FunctionCallbackInfo<v8:
 
             ret->SetAlignedPointerInInternalField(0, data);
 
-            SetNativeType(ret, NativeType::ImageData);
+            SetNativeType(data, NativeType::ImageData);
 
             args.GetReturnValue().Set(ret);
 
@@ -1629,7 +1629,7 @@ CanvasRenderingContext2DImpl::CreateImageData(const v8::FunctionCallbackInfo<v8:
 
         ret->SetAlignedPointerInInternalField(0, data);
 
-        SetNativeType(ret, NativeType::ImageData);
+        SetNativeType(data, NativeType::ImageData);
 
         args.GetReturnValue().Set(ret);
     }
@@ -2475,7 +2475,7 @@ CanvasRenderingContext2DImpl::GetImageData(const v8::FunctionCallbackInfo<v8::Va
 
         ret->SetAlignedPointerInInternalField(0, data);
 
-        SetNativeType(ret, NativeType::ImageData);
+        SetNativeType(data, NativeType::ImageData);
 
         args.GetReturnValue().Set(ret);
         return;
@@ -2648,7 +2648,7 @@ CanvasRenderingContext2DImpl::MeasureText(const v8::FunctionCallbackInfo<v8::Val
 
     data->BindFinalizer(isolate, ret);
 
-    SetNativeType(ret, NativeType::TextMetrics);
+    SetNativeType(data, NativeType::TextMetrics);
 
     args.GetReturnValue().Set(ret);
 
@@ -2957,7 +2957,7 @@ CanvasRenderingContext2DImpl::GetTransform(const v8::FunctionCallbackInfo<v8::Va
 
     ret->SetAlignedPointerInInternalField(0, object);
 
-    SetNativeType(ret, NativeType::Matrix);
+    SetNativeType(object, NativeType::Matrix);
 
     object->BindFinalizer(isolate, ret);
 

package/platforms/ios/src/cpp/canvas2d/CanvasRenderingContext2DImpl.h

@@ -171,7 +171,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = CanvasRenderingContext2DImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::CanvasRenderingContext2D);
+        SetNativeType(renderingContext, NativeType::CanvasRenderingContext2D);
         object->SetAlignedPointerInInternalField(0, renderingContext);
         renderingContext->BindFinalizer(isolate, object);
         return scope.Escape(object);
@@ -548,7 +548,8 @@ public:
                     canvas_native_context_clip(
                             ptr->GetContext(), path->GetPath(), CanvasFillRuleEvenOdd);
                     break;
-                default: break;
+                default:
+                    break;
             }
         }
 
@@ -909,7 +910,8 @@ public:
                             object->GetPath(),
                             CanvasFillRuleEvenOdd);
                     break;
-                default: break;
+                default:
+                    break;
             }
 
             ptr->UpdateInvalidateState();
@@ -948,7 +950,8 @@ public:
                 canvas_native_context_fill(
                         ptr->GetContext(), CanvasFillRuleEvenOdd);
                 break;
-            default: break;
+            default:
+                break;
         }
 
 
@@ -1023,7 +1026,8 @@ public:
         }
 
         return canvas_native_context_is_point_in_path(
-                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), CanvasFillRuleNonZero);
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y),
+                CanvasFillRuleNonZero);
     }
 
     static bool
@@ -1036,7 +1040,8 @@ public:
 
 
         return canvas_native_context_is_point_in_path(
-                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y), rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
+                ptr->GetContext(), static_cast<float>(x), static_cast<float>(y),
+                rule == 0 ? CanvasFillRuleNonZero : CanvasFillRuleEvenOdd);
     }
 
     static bool
@@ -1061,15 +1066,16 @@ public:
 
                     ret = canvas_native_context_is_point_in_path_with_path(
                             ptr->GetContext(),
-                            path->GetPath(), (float)x,  (float)y, CanvasFillRuleNonZero);
+                            path->GetPath(), (float) x, (float) y, CanvasFillRuleNonZero);
                     break;
                 case 1:
 
                     ret = canvas_native_context_is_point_in_path_with_path(
                             ptr->GetContext(),
-                            path->GetPath(),  (float)x,  (float)y, CanvasFillRuleEvenOdd);
+                            path->GetPath(), (float) x, (float) y, CanvasFillRuleEvenOdd);
+                    break;
+                default:
                     break;
-                default: break;
             }
 
         }
@@ -1447,7 +1453,6 @@ public:
     static void StrokeText(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 
-
     static void StrokeOval(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 

package/platforms/ios/src/cpp/canvas2d/ImageDataImpl.cpp

@@ -115,7 +115,7 @@ void ImageDataImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
         object->BindFinalizer(isolate, ret);
 
-        SetNativeType(ret, NativeType::ImageData);
+        SetNativeType(object, NativeType::ImageData);
 
         args.GetReturnValue().Set(ret);
         return;
@@ -136,7 +136,7 @@ void ImageDataImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
         ret->SetAlignedPointerInInternalField(0, object);
 
-        SetNativeType(ret, NativeType::ImageData);
+        SetNativeType(object, NativeType::ImageData);
 
         object->BindFinalizer(isolate, ret);
 

package/platforms/ios/src/cpp/canvas2d/ImageDataImpl.h

@@ -8,7 +8,7 @@
 #include "Common.h"
 #include "ObjectWrapperImpl.h"
 
-class ImageDataImpl: ObjectWrapperImpl {
+class ImageDataImpl : public ObjectWrapperImpl {
 public:
     explicit ImageDataImpl(ImageData* imageData);
 

package/platforms/ios/src/cpp/canvas2d/MatrixImpl.cpp

@@ -281,7 +281,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
                 ret->SetAlignedPointerInInternalField(0, object);
 
-                SetNativeType(ret, NativeType::Matrix);
+                SetNativeType(object, NativeType::Matrix);
 
                 object->BindFinalizer(isolate, ret);
 
@@ -307,7 +307,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
                 ret->SetAlignedPointerInInternalField(0, object);
 
-                SetNativeType(ret, NativeType::Matrix);
+                SetNativeType(object, NativeType::Matrix);
 
                 object->BindFinalizer(isolate, ret);
 
@@ -322,7 +322,7 @@ void MatrixImpl::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
         ret->SetAlignedPointerInInternalField(0, object);
 
-        SetNativeType(ret, NativeType::Matrix);
+        SetNativeType(object, NativeType::Matrix);
 
         object->BindFinalizer(isolate, ret);
 
@@ -897,7 +897,7 @@ void MatrixImpl::Translate(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
             ret->SetAlignedPointerInInternalField(0, object);
 
-            SetNativeType(ret, NativeType::Matrix);
+            SetNativeType(object, NativeType::Matrix);
 
             object->BindFinalizer(isolate, ret);
 
@@ -989,7 +989,7 @@ void MatrixImpl::ScaleNonUniform(const v8::FunctionCallbackInfo<v8::Value> &args
 
             ret->SetAlignedPointerInInternalField(0, object);
 
-            SetNativeType(ret, NativeType::Matrix);
+            SetNativeType(object, NativeType::Matrix);
 
             object->BindFinalizer(isolate, ret);
 
@@ -1048,7 +1048,7 @@ void MatrixImpl::Rotate(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
             ret->SetAlignedPointerInInternalField(0, object);
 
-            SetNativeType(ret, NativeType::Matrix);
+            SetNativeType(object, NativeType::Matrix);
 
             object->BindFinalizer(isolate, ret);
 
@@ -1105,7 +1105,7 @@ void MatrixImpl::SkewX(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
             ret->SetAlignedPointerInInternalField(0, object);
 
-            SetNativeType(ret, NativeType::Matrix);
+            SetNativeType(object, NativeType::Matrix);
 
             object->BindFinalizer(isolate, ret);
 
@@ -1144,7 +1144,7 @@ void MatrixImpl::SkewY(const v8::FunctionCallbackInfo<v8::Value> &args) {
         if (type == NativeType::Matrix) {
             auto ptr = MatrixImpl::GetPointer(value.As<v8::Object>());
             auto matrix = canvas_native_matrix_skew_y(
-                    angle->NumberValue(context).ToChecked(),
+                    (float) angle->NumberValue(context).ToChecked(),
                     ptr->GetMatrix());
             if (matrix == nullptr) {
                 args.GetReturnValue().SetUndefined();
@@ -1158,7 +1158,7 @@ void MatrixImpl::SkewY(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
             ret->SetAlignedPointerInInternalField(0, object);
 
-            SetNativeType(ret, NativeType::Matrix);
+            SetNativeType(object, NativeType::Matrix);
 
             object->BindFinalizer(isolate, ret);
 
@@ -1198,7 +1198,7 @@ void MatrixImpl::Clone(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     ret->SetAlignedPointerInInternalField(0, object);
 
-    SetNativeType(ret, NativeType::Matrix);
+    SetNativeType(object, NativeType::Matrix);
 
     object->BindFinalizer(isolate, ret);
 

package/platforms/ios/src/cpp/canvas2d/Path2D.cpp

@@ -75,8 +75,6 @@ void Path2D::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     auto ret = args.This();
 
-    SetNativeType(ret, NativeType::Path2D);
-
     if (count > 0) {
         if (value->IsString()) {
             auto d = ConvertFromV8String(isolate, value);
@@ -87,6 +85,8 @@ void Path2D::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
             object->BindFinalizer(isolate, ret);
 
+            SetNativeType(object, NativeType::Path2D);
+
             args.GetReturnValue().Set(ret);
 
             return;
@@ -102,6 +102,8 @@ void Path2D::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
                 object->BindFinalizer(isolate, ret);
 
+                SetNativeType(object, NativeType::Path2D);
+
                 args.GetReturnValue().Set(ret);
                 return;
             }
@@ -109,11 +111,12 @@ void Path2D::Ctor(const v8::FunctionCallbackInfo<v8::Value> &args) {
     } else {
         auto path = new Path2D(canvas_native_path_create());
 
-
         ret->SetAlignedPointerInInternalField(0, path);
 
         path->BindFinalizer(isolate, ret);
 
+        SetNativeType(path, NativeType::Path2D);
+
         args.GetReturnValue().Set(ret);
         return;
 

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

@@ -25,7 +25,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLActiveInfoImpl::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLActiveInfo);
+        SetNativeType( info, NativeType::WebGLActiveInfo);
         object->SetAlignedPointerInInternalField(0, info);
         info->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -35,7 +35,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLBuffer::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLBuffer);
+        SetNativeType( buffer, NativeType::WebGLBuffer);
         object->SetAlignedPointerInInternalField(0, buffer);
         buffer->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -35,7 +35,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLFramebuffer::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLFramebuffer);
+        SetNativeType( buffer, NativeType::WebGLFramebuffer);
         object->SetAlignedPointerInInternalField(0, buffer);
         buffer->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -9,9 +9,9 @@
 
 class WebGLProgram:ObjectWrapperImpl  {
 public:
-    WebGLProgram(uint32_t program) : program_(program) {}
+    explicit WebGLProgram(uint32_t program) : program_(program) {}
 
-    uint32_t GetProgram() {
+    uint32_t GetProgram() const {
         return this->program_;
     }
 
@@ -39,7 +39,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLProgram::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLProgram);
+        SetNativeType( program, NativeType::WebGLProgram);
         object->SetAlignedPointerInInternalField(0, program);
         program->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -8,7 +8,7 @@
 #include "ObjectWrapperImpl.h"
 class WebGLRenderbuffer: ObjectWrapperImpl {
 public:
-    WebGLRenderbuffer(uint32_t renderbuffer) : renderbuffer_(renderbuffer) {}
+    explicit WebGLRenderbuffer(uint32_t renderbuffer) : renderbuffer_(renderbuffer) {}
 
     static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
         auto cache = Caches::Get(isolate);
@@ -34,7 +34,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLRenderbuffer::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLRenderbuffer);
+        SetNativeType( buffer, NativeType::WebGLRenderbuffer);
         object->SetAlignedPointerInInternalField(0, buffer);
         buffer->BindFinalizer(isolate, object);
         return scope.Escape(object);
@@ -48,7 +48,7 @@ public:
         return static_cast<WebGLRenderbuffer *>(ptr);
     }
 
-    uint32_t GetRenderBuffer() {
+    uint32_t GetRenderBuffer() const {
         return this->renderbuffer_;
     }
 

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

@@ -301,7 +301,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLRenderingContext::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType(object, NativeType::WebGLRenderingContextBase);
+        SetNativeType(renderingContext, NativeType::WebGLRenderingContextBase);
         object->SetAlignedPointerInInternalField(0, renderingContext);
         renderingContext->BindFinalizer(isolate, object);
         return scope.Escape(object);

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

@@ -34,7 +34,7 @@ public:
         v8::EscapableHandleScope scope(isolate);
         auto object = WebGLShader::GetCtor(isolate)->GetFunction(
                 context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
-        SetNativeType( object, NativeType::WebGLShader);
+        SetNativeType( shader, NativeType::WebGLShader);
         object->SetAlignedPointerInInternalField(0, shader);
         shader->BindFinalizer(isolate, object);
         return scope.Escape(object);