@nativescript/canvas 2.0.0-beta.8 → 2.0.0-webgpu.0

package/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.cpp

@@ -0,0 +1,469 @@
+//
+// Created by Osei Fortune on 17/07/2024.
+//
+
+#include "GPURenderBundleEncoderImpl.h"
+#include "Caches.h"
+#include "GPURenderPipelineImpl.h"
+#include "GPUBufferImpl.h"
+#include "GPURenderBundleImpl.h"
+#include "GPUBindGroupImpl.h"
+
+GPURenderBundleEncoderImpl::GPURenderBundleEncoderImpl(const CanvasGPURenderBundleEncoder *encoder)
+        : encoder_(
+        encoder) {}
+
+const CanvasGPURenderBundleEncoder *GPURenderBundleEncoderImpl::GetEncoder() {
+    return this->encoder_;
+}
+
+
+void GPURenderBundleEncoderImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderBundleEncoder"),
+                      func).FromJust();
+}
+
+GPURenderBundleEncoderImpl *
+GPURenderBundleEncoderImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPURenderBundleEncoderImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPURenderBundleEncoderImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPURenderBundleEncoderTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPURenderBundleEncoder"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "draw"),
+            v8::FunctionTemplate::New(isolate, &Draw));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "drawIndexed"),
+            v8::FunctionTemplate::New(isolate, &DrawIndexed));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "drawIndexedIndirect"),
+            v8::FunctionTemplate::New(isolate, &DrawIndexedIndirect));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "drawIndirect"),
+            v8::FunctionTemplate::New(isolate, &DrawIndirect));
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "finish"),
+            v8::FunctionTemplate::New(isolate, &Finish));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "insertDebugMarker"),
+            v8::FunctionTemplate::New(isolate, &InsertDebugMarker));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "popDebugGroup"),
+            v8::FunctionTemplate::New(isolate, &PopDebugGroup));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "pushDebugGroup"),
+            v8::FunctionTemplate::New(isolate, &PushDebugGroup));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "setBindGroup"),
+            v8::FunctionTemplate::New(isolate, &SetBindGroup));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "setIndexBuffer"),
+            v8::FunctionTemplate::New(isolate, &SetIndexBuffer));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "setPipeline"),
+            v8::FunctionTemplate::New(isolate, &SetPipeline));
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "setVertexBuffer"),
+            v8::FunctionTemplate::New(isolate, &SetVertexBuffer));
+
+
+    cache->GPURenderBundleEncoderTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void GPURenderBundleEncoderImpl::Draw(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto vertexCountVal = args[0];
+    auto instanceCountVal = args[1];
+    uint32_t instanceCount = 1;
+    uint32_t firstVertex = 0;
+    uint32_t firstInstance = 0;
+    auto firstVertexVal = args[2];
+    auto firstInstanceVal = args[3];
+
+    if (vertexCountVal->IsUint32()) {
+        auto vertexCount = vertexCountVal.As<v8::Uint32>()->Value();
+
+
+        if (instanceCountVal->IsUint32()) {
+            instanceCount = instanceCountVal.As<v8::Uint32>()->Value();
+        }
+
+        if (firstVertexVal->IsUint32()) {
+            firstVertex = firstVertexVal.As<v8::Uint32>()->Value();
+        }
+
+        if (firstInstanceVal->IsUint32()) {
+            firstInstance = firstInstanceVal.As<v8::Uint32>()->Value();
+        }
+
+        canvas_native_webgpu_render_bundle_encoder_draw(ptr->GetEncoder(), vertexCount,
+                                                        instanceCount,
+                                                        firstVertex, firstInstance);
+
+    }
+}
+
+void GPURenderBundleEncoderImpl::DrawIndexed(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    uint32_t instanceCount = 1;
+    uint32_t firstIndex = 0;
+    int32_t baseVertex = 0;
+    uint32_t firstInstance = 0;
+
+
+    auto indexCountVal = args[0];
+    auto firstIndexVal = args[1];
+    auto baseVertexVal = args[2];
+    auto firstInstanceVal = args[3];
+
+    if (indexCountVal->IsUint32()) {
+
+
+        if (firstIndexVal->IsUint32()) {
+            firstIndex = firstIndexVal.As<v8::Uint32>()->Value();
+        }
+
+        if (baseVertexVal->IsInt32()) {
+            baseVertex = baseVertexVal.As<v8::Int32>()->Value();
+        }
+
+        if (firstInstanceVal->IsUint32()) {
+            firstInstance = firstInstanceVal.As<v8::Uint32>()->Value();
+        }
+
+        canvas_native_webgpu_render_bundle_encoder_draw_indexed(ptr->GetEncoder(),
+                                                                indexCountVal->Uint32Value(
+                                                                        context).FromJust(),
+                                                                instanceCount, firstIndex,
+                                                                baseVertex,
+                                                                firstInstance);
+    }
+
+
+}
+
+void
+GPURenderBundleEncoderImpl::DrawIndexedIndirect(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto indirectBufferVal = args[0];
+    auto indirectOffsetVal = args[1];
+
+
+    auto indirectBufferType = GetNativeType(indirectBufferVal);
+
+    if (indirectBufferType == NativeType::GPUBuffer) {
+        auto indirectBuffer = GPUBufferImpl::GetPointer(indirectBufferVal.As<v8::Object>());
+        uint64_t offset = (uint64_t) indirectOffsetVal->NumberValue(context).FromJust();
+        canvas_native_webgpu_render_bundle_encoder_draw_indexed_indirect(ptr->GetEncoder(),
+                                                                         indirectBuffer->GetGPUBuffer(),
+                                                                         offset);
+    }
+
+
+}
+
+void
+GPURenderBundleEncoderImpl::DrawIndirect(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto indirectBufferVal = args[0];
+    auto indirectOffsetVal = args[1];
+
+
+    auto indirectBufferType = GetNativeType(indirectBufferVal);
+
+    if (indirectBufferType == NativeType::GPUBuffer) {
+        auto indirectBuffer = GPUBufferImpl::GetPointer(indirectBufferVal.As<v8::Object>());
+        uint64_t offset = (uint64_t) indirectOffsetVal->NumberValue(context).FromJust();
+        canvas_native_webgpu_render_bundle_encoder_draw_indirect(ptr->GetEncoder(),
+                                                                 indirectBuffer->GetGPUBuffer(),
+                                                                 offset);
+    }
+
+
+}
+
+void GPURenderBundleEncoderImpl::Finish(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    char *label = nullptr;
+    v8::Local<v8::Value> labelVal;
+
+    auto optionsVal = args[0];
+
+    if (optionsVal->IsObject()) {
+        auto options = optionsVal.As<v8::Object>();
+        options->Get(context, ConvertToV8String(isolate, "label")).ToLocal(&labelVal);
+
+        if (!labelVal.IsEmpty() && labelVal->IsString()) {
+            label = *v8::String::Utf8Value(isolate, labelVal);
+        }
+    }
+
+
+    auto bundle = canvas_native_webgpu_render_bundle_encoder_finish(ptr->GetEncoder(), label);
+
+    if (bundle != nullptr) {
+        auto ret = GPURenderBundleImpl::NewInstance(isolate, new GPURenderBundleImpl(bundle));
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+
+void
+GPURenderBundleEncoderImpl::InsertDebugMarker(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+
+    auto markerLabelVal = args[0];
+    if (markerLabelVal->IsString()) {
+        auto markerLabel = ConvertFromV8String(isolate, markerLabelVal);
+        canvas_native_webgpu_render_bundle_encoder_insert_debug_marker(ptr->GetEncoder(),
+                                                                       markerLabel.c_str());
+    }
+}
+
+void GPURenderBundleEncoderImpl::PopDebugGroup(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    canvas_native_webgpu_render_bundle_encoder_pop_debug_group(ptr->GetEncoder());
+}
+
+void GPURenderBundleEncoderImpl::PushDebugGroup(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+
+    auto groupLabelVal = args[0];
+    if (groupLabelVal->IsString()) {
+        auto groupLabel = ConvertFromV8String(isolate, groupLabelVal);
+        canvas_native_webgpu_render_bundle_encoder_push_debug_group(ptr->GetEncoder(),
+                                                                    groupLabel.c_str());
+    }
+}
+
+void GPURenderBundleEncoderImpl::SetBindGroup(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto indexVal = args[0];
+    auto bindGroupVal = args[1];
+    auto dynamicOffsets = args[2];
+    auto dynamicOffsetsStart = args[3];
+    auto dynamicOffsetsLength = args[4];
+
+    auto type = GetNativeType(bindGroupVal);
+
+    if (type == NativeType::GPUBindGroup) {
+        auto index = indexVal->Uint32Value(context).FromJust();
+        auto bindGroup = GPUBindGroupImpl::GetPointer(bindGroupVal.As<v8::Object>());
+
+        if (dynamicOffsets->IsUint8Array()) {
+            auto buf = dynamicOffsets.As<v8::Uint32Array>();
+            auto buffer = buf->Buffer();
+            auto store = buffer->GetBackingStore();
+            auto offset = buf->ByteOffset();
+            auto data = static_cast<uint8_t *>(buffer->GetBackingStore()->Data()) + offset;
+            auto size = buf->Length();
+            auto start = (size_t) dynamicOffsetsStart->NumberValue(context).FromJust();
+            auto offset_length = (size_t) dynamicOffsetsLength->NumberValue(context).FromJust();
+            canvas_native_webgpu_render_bundle_encoder_set_bind_group(ptr->GetEncoder(), index,
+                                                                      bindGroup->GetBindGroup(),
+                                                                      static_cast<const uint32_t *>(static_cast<void *>(data)),
+                                                                      size, start, offset_length);
+        } else {
+            canvas_native_webgpu_render_bundle_encoder_set_bind_group(ptr->GetEncoder(), index,
+                                                                      bindGroup->GetBindGroup(),
+                                                                      nullptr, 0, 0, 0);
+        }
+    }
+
+}
+
+void GPURenderBundleEncoderImpl::SetIndexBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto bufferVal = args[0];
+    auto indexFormatVal = args[1];
+    int64_t offset = -1;
+    int64_t size = -1;
+    auto offsetVal = args[2];
+    auto sizeVal = args[3];
+
+    auto type = GetNativeType(bufferVal);
+
+    if (type == NativeType::GPURenderBundleEncoder) {
+        auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
+        auto indexFormat = ConvertFromV8String(isolate, indexFormatVal);
+        if (offsetVal->IsNumber()) {
+            offset = (int64_t) offsetVal.As<v8::Number>()->Value();
+        }
+
+        if (sizeVal->IsNumber()) {
+            size = (int64_t) sizeVal.As<v8::Number>()->Value();
+        }
+
+        if (indexFormat == "uint16") {
+            canvas_native_webgpu_render_bundle_encoder_set_index_buffer(ptr->GetEncoder(),
+                                                                        buffer->GetGPUBuffer(),
+                                                                        CanvasIndexFormatUint16,
+                                                                        offset,
+                                                                        size);
+        } else if (indexFormat == "uint32") {
+            canvas_native_webgpu_render_bundle_encoder_set_index_buffer(ptr->GetEncoder(),
+                                                                        buffer->GetGPUBuffer(),
+                                                                        CanvasIndexFormatUint32,
+                                                                        offset,
+                                                                        size);
+        }
+
+
+    }
+}
+
+void GPURenderBundleEncoderImpl::SetPipeline(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto pipelineVal = args[0];
+    if (pipelineVal->IsObject()) {
+        auto pipeline = GPURenderPipelineImpl::GetPointer(pipelineVal.As<v8::Object>());
+        if (pipeline != nullptr) {
+            canvas_native_webgpu_render_bundle_encoder_set_pipeline(ptr->GetEncoder(),
+                                                                    pipeline->GetGPUPipeline());
+        }
+    }
+}
+
+void GPURenderBundleEncoderImpl::SetVertexBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto slotVal = args[0];
+    auto bufferVal = args[1];
+    int64_t offset = -1;
+    int64_t size = -1;
+    auto offsetVal = args[2];
+    auto sizeVal = args[3];
+
+    if (slotVal->IsUint32() && bufferVal->IsObject()) {
+        auto slot = slotVal.As<v8::Uint32>()->Value();
+        auto buffer = GPUBufferImpl::GetPointer(bufferVal.As<v8::Object>());
+        if (buffer == nullptr) {
+            // todo throw ??
+            return;
+        }
+
+        if (offsetVal->IsNumber()) {
+            offset = (int64_t) offsetVal.As<v8::Number>()->Value();
+        }
+
+        if (sizeVal->IsNumber()) {
+            size = (int64_t) sizeVal.As<v8::Number>()->Value();
+        }
+
+        canvas_native_webgpu_render_bundle_encoder_set_vertex_buffer(ptr->GetEncoder(), slot,
+                                                                     buffer->GetGPUBuffer(), offset,
+                                                                     size);
+
+    }
+}
+
+

package/platforms/ios/src/cpp/webgpu/GPURenderBundleEncoderImpl.h

@@ -0,0 +1,71 @@
+//
+// Created by Osei Fortune on 17/07/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPURENDERBUNDLEENCODERIMPL_H
+#define CANVAS_ANDROID_GPURENDERBUNDLEENCODERIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPURenderBundleEncoderImpl : ObjectWrapperImpl {
+
+public:
+    explicit GPURenderBundleEncoderImpl(const CanvasGPURenderBundleEncoder *encoder);
+
+    ~GPURenderBundleEncoderImpl() {
+        canvas_native_webgpu_render_bundle_encoder_release(this->GetEncoder());
+    }
+
+    const CanvasGPURenderBundleEncoder *GetEncoder();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPURenderBundleEncoderImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, GPURenderBundleEncoderImpl *encoder) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPURenderBundleEncoderImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPURenderBundleEncoder);
+        object->SetAlignedPointerInInternalField(0, encoder);
+        encoder->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void Draw(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawIndexed(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawIndexedIndirect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawIndirect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Finish(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void InsertDebugMarker(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PopDebugGroup(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PushDebugGroup(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetBindGroup(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetIndexBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetPipeline(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetVertexBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+private:
+    const CanvasGPURenderBundleEncoder *encoder_;
+};
+
+
+#endif //CANVAS_ANDROID_GPURENDERBUNDLEENCODERIMPL_H

package/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.cpp

@@ -0,0 +1,53 @@
+//
+// Created by Osei Fortune on 18/07/2024.
+//
+
+#include "GPURenderBundleImpl.h"
+#include "Caches.h"
+
+GPURenderBundleImpl::GPURenderBundleImpl(const CanvasGPURenderBundle *bundle) : bundle_(
+        bundle) {}
+
+const CanvasGPURenderBundle *GPURenderBundleImpl::GetBundle() {
+    return this->bundle_;
+}
+
+
+void GPURenderBundleImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate) {
+    v8::Locker locker(isolate);
+    v8::Isolate::Scope isolate_scope(isolate);
+    v8::HandleScope handle_scope(isolate);
+
+    auto ctor = GetCtor(isolate);
+    auto context = isolate->GetCurrentContext();
+    auto func = ctor->GetFunction(context).ToLocalChecked();
+
+    canvasModule->Set(context, ConvertToV8String(isolate, "GPURenderBundle"), func).FromJust();;
+}
+
+GPURenderBundleImpl *GPURenderBundleImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPURenderBundleImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPURenderBundleImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPURenderBundleTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "GPURenderBundle"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    cache->GPURenderBundleTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}

package/platforms/ios/src/cpp/webgpu/GPURenderBundleImpl.h

@@ -0,0 +1,45 @@
+//
+// Created by Osei Fortune on 18/07/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPURENDERBUNDLEIMPL_H
+#define CANVAS_ANDROID_GPURENDERBUNDLEIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPURenderBundleImpl : ObjectWrapperImpl {
+public:
+    explicit GPURenderBundleImpl(const CanvasGPURenderBundle *bundle);
+
+    ~GPURenderBundleImpl() {
+        canvas_native_webgpu_render_bundle_release(this->bundle_);
+    }
+
+    const CanvasGPURenderBundle *GetBundle();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPURenderBundleImpl *GetPointer(const v8::Local<v8::Object> &object);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, GPURenderBundleImpl *bundle) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPURenderBundleImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPURenderBundle);
+        object->SetAlignedPointerInInternalField(0, bundle);
+        bundle->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+
+private:
+    const CanvasGPURenderBundle *bundle_;
+};
+
+
+#endif //CANVAS_ANDROID_GPURENDERBUNDLEIMPL_H