@nativescript/canvas 2.0.0-beta.9 → 2.0.0-webgpu.1

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

@@ -0,0 +1,302 @@
+//
+// Created by Osei Fortune on 17/06/2024.
+//
+
+#include "GPUAdapterImpl.h"
+#include "Caches.h"
+
+GPUAdapterImpl::GPUAdapterImpl(const CanvasGPUAdapter *adapter) : adapter_(adapter) {}
+
+const CanvasGPUAdapter *GPUAdapterImpl::GetGPUAdapter() {
+    return this->adapter_;
+}
+
+
+void GPUAdapterImpl::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, "GPUAdapter"), func).FromJust();
+}
+
+GPUAdapterImpl *GPUAdapterImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUAdapterImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUAdapterImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUAdapterTmpl.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, "GPUAdapter"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "features"),
+            GetFeatures
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "isFallbackAdapter"),
+            GetIsFallbackAdapter
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "limits"),
+            GetLimits
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "requestAdapterInfo"),
+            v8::FunctionTemplate::New(isolate, &RequestAdapterInfo));
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "requestDevice"),
+            v8::FunctionTemplate::New(isolate, &RequestDevice));
+
+
+    cache->GPUAdapterTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void
+GPUAdapterImpl::GetFeatures(v8::Local<v8::Name> name,
+                            const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    auto isolate = info.GetIsolate();
+    if (ptr != nullptr) {
+        auto context = isolate->GetCurrentContext();
+
+        auto features = canvas_native_webgpu_adapter_get_features(ptr->GetGPUAdapter());
+
+        auto len = canvas_native_string_buffer_get_length(features);
+
+        auto map = v8::Map::New(isolate);
+        for (int i = 0; i < len; ++i) {
+            auto item = canvas_native_string_buffer_get_value_at(features, i);
+            if (item != nullptr) {
+                auto keyValue = ConvertToV8OneByteString(isolate, (char *) item);
+                map->Set(context, keyValue, keyValue);
+                canvas_native_string_destroy(item);
+            }
+
+        }
+        canvas_native_string_buffer_destroy(features);
+
+        info.GetReturnValue().Set(map);
+
+        return;
+    }
+
+    info.GetReturnValue().Set(v8::Map::New(info.GetIsolate()));
+}
+
+void
+GPUAdapterImpl::GetIsFallbackAdapter(v8::Local<v8::Name> name,
+                                     const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        info.GetReturnValue().Set(
+                canvas_native_webgpu_adapter_is_fallback_adapter(ptr->GetGPUAdapter())
+        );
+        return;
+    }
+    info.GetReturnValue().Set(false);
+}
+
+void
+GPUAdapterImpl::GetLimits(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto limits = canvas_native_webgpu_adapter_get_limits(ptr->GetGPUAdapter());
+        auto ret = GPUSupportedLimitsImpl::NewInstance(info.GetIsolate(),
+                                                       new GPUSupportedLimitsImpl(limits));
+        info.GetReturnValue().Set(ret);
+        return;
+    }
+    info.GetReturnValue().SetUndefined();
+}
+
+
+void GPUAdapterImpl::RequestAdapterInfo(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUAdapterImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+
+    auto info = canvas_native_webgpu_adapter_request_adapter_info(ptr->GetGPUAdapter());
+
+    if (info != nullptr) {
+        auto value = new GPUAdapterInfoImpl(info);
+        auto ret = GPUAdapterInfoImpl::NewInstance(isolate, value);
+        args.GetReturnValue().Set(ret);
+    } else {
+        args.GetReturnValue().SetUndefined();
+    }
+
+}
+
+void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUAdapterImpl *ptr = GetPointer(args.This());
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto optionsValue = args[0];
+    auto cb = args[1];
+    if (ptr == nullptr) {
+        // todo error
+        cb.As<v8::Function>()->Call(context, context->Global(), 0, nullptr);
+        return;
+    }
+
+    v8::Global<v8::Function> func(isolate, cb.As<v8::Function>());
+
+    std::string label;
+
+    std::vector<std::string> required_features_buf;
+
+    CanvasGPUSupportedLimits *limits = nullptr;
+
+    if (!optionsValue.IsEmpty() && optionsValue->IsObject()) {
+        auto options = optionsValue.As<v8::Object>();
+        v8::Local<v8::Value> labelValue;
+        options->Get(context, ConvertToV8String(isolate, "label")).ToLocal(
+                &labelValue);
+
+        if (!labelValue.IsEmpty() && labelValue->IsString()) {
+            label = ConvertFromV8String(isolate, labelValue);
+        }
+
+        v8::Local<v8::Value> requiredFeaturesValue;
+
+        options->Get(context, ConvertToV8String(isolate, "requiredFeatures")).ToLocal(
+                &requiredFeaturesValue);
+
+
+        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsSet()) {
+            v8::Local<v8::Set> requiredFeaturesSet = requiredFeaturesValue.As<v8::Set>();
+            v8::Local<v8::Array> requiredFeatures = requiredFeaturesSet->AsArray();
+            auto len = requiredFeatures->Length();
+
+            for (int i = 0; i < len; i++) {
+                auto item = requiredFeatures->Get(context, i);
+                if (!item.IsEmpty()) {
+                    auto value = item.ToLocalChecked();
+                    if (value->IsString()) {
+                        required_features_buf.push_back(ConvertFromV8String(isolate, value));
+                    }
+                }
+            }
+        }
+
+
+        v8::Local<v8::Value> limitsValue;
+
+        options->Get(context, ConvertToV8String(isolate, "requiredLimits")).ToLocal(
+                &limitsValue);
+
+        if (!limitsValue.IsEmpty() && limitsValue->IsObject()) {
+            auto limits_ptr = GPUSupportedLimitsImpl::GetPointer(limitsValue.As<v8::Object>());
+            if (limits_ptr != nullptr) {
+                limits = limits_ptr->GetLimits();
+            }
+        }
+    }
+
+    char **required_features_data = nullptr;
+    size_t required_features_data_length = required_features_buf.size();
+
+    if (required_features_data_length > 0) {
+        required_features_data = new char *[required_features_data_length + 1];
+
+        for (size_t i = 0; i < required_features_data_length; ++i) {
+            std::strcpy(required_features_data[i], required_features_buf[i].c_str());
+        }
+    }
+
+
+    auto callback = new AsyncCallback{
+            isolate,
+            std::move(func),
+            static_cast<void *>(required_features_data)
+    };
+
+    canvas_native_webgpu_adapter_request_device(ptr->GetGPUAdapter(),
+                                        label.empty() ? nullptr : label.c_str(),
+                                        required_features_data, required_features_data_length,
+                                        limits,
+                                        [](char *error, const CanvasGPUDevice *device, void *data) {
+                                            if (data != nullptr) {
+                                                auto func = static_cast<AsyncCallback *>(data);
+                                                if (func->isolate != nullptr) {
+                                                    v8::Isolate *isolate = func->isolate;
+                                                    v8::Locker locker(isolate);
+                                                    v8::Isolate::Scope isolate_scope(isolate);
+                                                    v8::HandleScope handle_scope(isolate);
+                                                    v8::Local<v8::Function> callback = func->callback.Get(
+                                                            isolate);
+                                                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                                                    v8::Context::Scope context_scope(context);
+
+                                                    if (func->data != nullptr) {
+                                                        delete[] static_cast<char **>(func->data);
+                                                        func->data = nullptr;
+                                                    }
+
+                                                    if (error != nullptr) {
+                                                        v8::Local<v8::Value> args[1] = {
+                                                                v8::Exception::Error(
+                                                                        ConvertToV8String(isolate,
+                                                                                          error))};
+
+                                                        canvas_native_string_destroy(error);
+
+                                                        callback->Call(context, context->Global(),
+                                                                       1,
+                                                                       args);  // ignore JS return value
+                                                        delete static_cast<AsyncCallback *>(data);
+                                                    } else {
+
+                                                        auto impl = new GPUDeviceImpl(device);
+                                                        auto ret = GPUDeviceImpl::NewInstance(
+                                                                isolate, impl);
+
+
+                                                        v8::Local<v8::Value> args[2] = {
+                                                                v8::Null(isolate), ret};
+
+
+                                                        callback->Call(context, context->Global(),
+                                                                       2,
+                                                                       args);  // ignore JS return value
+
+                                                        delete static_cast<AsyncCallback *>(data);
+
+                                                    }
+                                                }
+                                            }
+                                        }, callback);
+
+
+}

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

@@ -0,0 +1,63 @@
+//
+// Created by Osei Fortune on 17/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUADAPTERIMPL_H
+#define CANVAS_ANDROID_GPUADAPTERIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+#include "GPUSupportedLimitsImpl.h"
+#include "GPUDeviceImpl.h"
+#include "GPUAdapterInfoImpl.h"
+
+class GPUAdapterImpl : ObjectWrapperImpl {
+public:
+    explicit GPUAdapterImpl(const CanvasGPUAdapter *adapter);
+
+    ~GPUAdapterImpl() {
+        canvas_native_webgpu_adapter_release(this->GetGPUAdapter());
+    }
+
+    const CanvasGPUAdapter *GetGPUAdapter();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUAdapterImpl *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, GPUAdapterImpl *adapter) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUAdapterImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUAdapter);
+        object->SetAlignedPointerInInternalField(0, adapter);
+        adapter->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetFeatures(v8::Local<v8::Name> name,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+    static void GetIsFallbackAdapter(v8::Local<v8::Name> name,
+                                     const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetLimits(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+    static void RequestAdapterInfo(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+private:
+    const CanvasGPUAdapter *adapter_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUADAPTERIMPL_H

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

@@ -0,0 +1,174 @@
+//
+// Created by Osei Fortune on 17/06/2024.
+//
+
+#include "GPUAdapterInfoImpl.h"
+#include "Caches.h"
+
+GPUAdapterInfoImpl::GPUAdapterInfoImpl(const CanvasGPUAdapterInfo *info) : info_(info) {}
+
+const CanvasGPUAdapterInfo *GPUAdapterInfoImpl::GetInfo() {
+    return this->info_;
+}
+
+
+void GPUAdapterInfoImpl::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, "GPUAdapterInfo"), func).FromJust();;
+}
+
+GPUAdapterInfoImpl *GPUAdapterInfoImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUAdapterInfoImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUAdapterInfoImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUAdapterInfoTmpl.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, "GPUAdapterInfo"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "architecture"),
+            GetArchitecture
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "description"),
+            GetDescription
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "device"),
+            GetDevice
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "vendor"),
+            GetVendor
+    );
+
+
+    cache->GPUAdapterInfoTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void
+GPUAdapterInfoImpl::GetArchitecture(v8::Local<v8::Name> name,
+                                    const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+
+    if (ptr == nullptr) {
+        info.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto architecture = canvas_native_webgpu_adapter_info_architecture(ptr->GetInfo());
+
+    if (architecture == nullptr) {
+        info.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto ret = ConvertToV8String(info.GetIsolate(), architecture);
+
+    canvas_native_string_destroy(architecture);
+
+    info.GetReturnValue().Set(ret);
+}
+
+
+void
+GPUAdapterInfoImpl::GetDescription(v8::Local<v8::Name> name,
+                                   const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+
+    if (ptr == nullptr) {
+        info.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto description = canvas_native_webgpu_adapter_info_description(ptr->GetInfo());
+
+    if (description == nullptr) {
+        info.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto ret = ConvertToV8String(info.GetIsolate(), description);
+
+    canvas_native_string_destroy(description);
+
+    info.GetReturnValue().Set(ret);
+}
+
+
+void
+GPUAdapterInfoImpl::GetDevice(v8::Local<v8::Name> name,
+                              const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+
+    if (ptr == nullptr) {
+        info.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto device = canvas_native_webgpu_adapter_info_device(ptr->GetInfo());
+
+    if (device == nullptr) {
+        info.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto ret = ConvertToV8String(info.GetIsolate(), device);
+
+    canvas_native_string_destroy(device);
+
+    info.GetReturnValue().Set(ret);
+}
+
+
+void
+GPUAdapterInfoImpl::GetVendor(v8::Local<v8::Name> name,
+                              const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+
+    if (ptr == nullptr) {
+        info.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto vendor = canvas_native_webgpu_adapter_info_vendor(ptr->GetInfo());
+
+    if (vendor == nullptr) {
+        info.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto ret = ConvertToV8String(info.GetIsolate(), vendor);
+
+    canvas_native_string_destroy(vendor);
+
+    info.GetReturnValue().Set(ret);
+}
+

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

@@ -0,0 +1,58 @@
+//
+// Created by Osei Fortune on 17/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUADAPTERINFOIMPL_H
+#define CANVAS_ANDROID_GPUADAPTERINFOIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUAdapterInfoImpl : ObjectWrapperImpl {
+public:
+    explicit GPUAdapterInfoImpl(const CanvasGPUAdapterInfo *info);
+
+    ~GPUAdapterInfoImpl() {
+        canvas_native_webgpu_adapter_info_release(this->GetInfo());
+    }
+
+    const CanvasGPUAdapterInfo *GetInfo();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUAdapterInfoImpl *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, GPUAdapterInfoImpl *info) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUAdapterInfoImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUAdapterInfo);
+        object->SetAlignedPointerInInternalField(0, info);
+        info->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetArchitecture(v8::Local<v8::Name> name,
+                                const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+    static void GetDescription(v8::Local<v8::Name> name,
+                               const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetDevice(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetVendor(v8::Local<v8::Name> name,
+                          const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+private:
+    const CanvasGPUAdapterInfo *info_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUADAPTERINFOIMPL_H

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

@@ -0,0 +1,53 @@
+//
+// Created by Osei Fortune on 17/07/2024.
+//
+
+#include "GPUBindGroupImpl.h"
+#include "Caches.h"
+
+GPUBindGroupImpl::GPUBindGroupImpl(const CanvasGPUBindGroup *groupLayout)
+        : group_(groupLayout) {}
+
+const CanvasGPUBindGroup *GPUBindGroupImpl::GetBindGroup() {
+    return this->group_;
+}
+
+
+void GPUBindGroupImpl::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, "GPUBindGroup"), func).FromJust();;
+}
+
+GPUBindGroupImpl *GPUBindGroupImpl::GetPointer(const v8::Local <v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUBindGroupImpl *>(ptr);
+}
+
+v8::Local <v8::FunctionTemplate> GPUBindGroupImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUBindGroupTmpl.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, "GPUBindGroup"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    cache->GPUBindGroupTmpl =
+            std::make_unique < v8::Persistent < v8::FunctionTemplate >> (isolate, ctorTmpl);
+    return ctorTmpl;
+}

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

@@ -0,0 +1,45 @@
+//
+// Created by Osei Fortune on 17/07/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUBINDGROUPIMPL_H
+#define CANVAS_ANDROID_GPUBINDGROUPIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUBindGroupImpl : ObjectWrapperImpl {
+public:
+    GPUBindGroupImpl(const CanvasGPUBindGroup *group);
+
+    ~GPUBindGroupImpl() {
+        canvas_native_webgpu_bind_group_release(this->GetBindGroup());
+    }
+
+    const CanvasGPUBindGroup *GetBindGroup();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUBindGroupImpl *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, GPUBindGroupImpl *groupLayout) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUBindGroupImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUBindGroup);
+        object->SetAlignedPointerInInternalField(0, groupLayout);
+        groupLayout->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+private:
+    const CanvasGPUBindGroup *group_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUBINDGROUPIMPL_H