@nativescript/canvas 2.0.0-beta.9 → 2.0.0-rc.0

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(info, 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,79 @@
+//
+// 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);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
+    cache->GPUBindGroupTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate >>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void
+GPUBindGroupImpl::GetLabel(v8::Local<v8::Name> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_bind_group_get_label(ptr->group_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}

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

@@ -0,0 +1,48 @@
+//
+// 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:
+    explicit 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(groupLayout, NativeType::GPUBindGroup);
+        object->SetAlignedPointerInInternalField(0, groupLayout);
+        groupLayout->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+private:
+    const CanvasGPUBindGroup *group_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUBINDGROUPIMPL_H

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

@@ -0,0 +1,79 @@
+//
+// Created by Osei Fortune on 29/06/2024.
+//
+
+#include "GPUBindGroupLayoutImpl.h"
+#include "Caches.h"
+
+GPUBindGroupLayoutImpl::GPUBindGroupLayoutImpl(const CanvasGPUBindGroupLayout *groupLayout)
+        : groupLayout_(groupLayout) {}
+
+const CanvasGPUBindGroupLayout *GPUBindGroupLayoutImpl::GetBindGroupLayout() {
+    return this->groupLayout_;
+}
+
+
+void GPUBindGroupLayoutImpl::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, "GPUBindGroupLayout"), func).FromJust();
+}
+
+GPUBindGroupLayoutImpl *GPUBindGroupLayoutImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUBindGroupLayoutImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUBindGroupLayoutImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUBindGroupLayoutTmpl.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, "GPUBindGroupLayout"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
+    cache->GPUBindGroupLayoutTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void
+GPUBindGroupLayoutImpl::GetLabel(v8::Local<v8::Name> name,
+                           const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_bind_group_layout_get_label(ptr->groupLayout_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}

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

@@ -0,0 +1,48 @@
+//
+// Created by Osei Fortune on 29/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUBINDGROUPLAYOUTIMPL_H
+#define CANVAS_ANDROID_GPUBINDGROUPLAYOUTIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUBindGroupLayoutImpl : ObjectWrapperImpl {
+public:
+    explicit GPUBindGroupLayoutImpl(const CanvasGPUBindGroupLayout *groupLayout);
+
+    ~GPUBindGroupLayoutImpl() {
+        canvas_native_webgpu_bind_group_layout_release(this->GetBindGroupLayout());
+    }
+
+    const CanvasGPUBindGroupLayout *GetBindGroupLayout();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUBindGroupLayoutImpl *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, GPUBindGroupLayoutImpl *groupLayout) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUBindGroupLayoutImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(groupLayout, NativeType::GPUBindGroupLayout);
+        object->SetAlignedPointerInInternalField(0, groupLayout);
+        groupLayout->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+private:
+    const CanvasGPUBindGroupLayout *groupLayout_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUBINDGROUPLAYOUTIMPL_H

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

@@ -0,0 +1,277 @@
+//
+// Created by Osei Fortune on 18/06/2024.
+//
+
+#include "GPUBufferImpl.h"
+#include "Caches.h"
+
+GPUBufferImpl::GPUBufferImpl(const CanvasGPUBuffer *buffer) : buffer_(buffer) {}
+
+const CanvasGPUBuffer *GPUBufferImpl::GetGPUBuffer() {
+    return this->buffer_;
+}
+
+
+void GPUBufferImpl::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, "GPUBuffer"), func).FromJust();
+}
+
+GPUBufferImpl *GPUBufferImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUBufferImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUBufferImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUBufferTmpl.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, "GPUBuffer"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "usage"),
+            GetUsage
+    );
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "size"),
+            GetSize
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "destroy"),
+            v8::FunctionTemplate::New(isolate, &Destroy));
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "mapAsync"),
+            v8::FunctionTemplate::New(isolate, &MapAsync));
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "unmap"),
+            v8::FunctionTemplate::New(isolate, &UnMap));
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getMappedRange"),
+            v8::FunctionTemplate::New(isolate, &GetMappedRange));
+
+    tmpl->SetLazyDataProperty(
+            ConvertToV8String(isolate, "label"),
+            GetLabel
+    );
+
+
+    cache->GPUBufferTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+
+void
+GPUBufferImpl::GetUsage(v8::Local<v8::Name> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto usage = canvas_native_webgpu_buffer_usage(ptr->GetGPUBuffer());
+        info.GetReturnValue().Set(
+                usage
+        );
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+
+void
+GPUBufferImpl::GetSize(v8::Local<v8::Name> name,
+                       const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto size = canvas_native_webgpu_buffer_size(ptr->GetGPUBuffer());
+        info.GetReturnValue().Set((double) size);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+
+void GPUBufferImpl::Destroy(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUBufferImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    canvas_native_webgpu_buffer_destroy(ptr->GetGPUBuffer());
+}
+
+
+void GPUBufferImpl::UnMap(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUBufferImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    canvas_native_webgpu_buffer_unmap(ptr->GetGPUBuffer());
+}
+
+struct MapAsyncData {
+    enum CanvasGPUErrorType type;
+    char* error;
+};
+
+void GPUBufferImpl::MapAsync(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUBufferImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto mode = args[0]->Int32Value(context).ToChecked();
+
+    int64_t offset = -1;
+    int64_t size = -1;
+
+    auto offsetVal = args[1];
+    if (offsetVal->IsNumber()) {
+        offset = (int64_t) offsetVal.As<v8::Number>()->Value();
+    }
+
+    auto sizeVal = args[2];
+
+    if (sizeVal->IsNumber()) {
+        size = (int64_t) sizeVal.As<v8::Number>()->Value();
+    }
+
+    auto resolver = v8::Promise::Resolver::New(isolate->GetCurrentContext()).ToLocalChecked();
+    args.GetReturnValue().Set(resolver->GetPromise());
+
+    auto callback = new PromiseCallback{
+            isolate,
+            resolver,
+            [](bool done, void *data){
+                auto async_data = static_cast<PromiseCallback *>(data);
+                auto func = async_data->inner_.get();
+                if (func != nullptr && 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::Promise::Resolver> callback = func->callback_.Get(
+                            isolate);
+                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                    v8::Context::Scope context_scope(
+                            context);
+
+
+                    if (func->data == nullptr) {
+                        callback->Resolve(context, v8::Undefined(isolate));
+                    } else {
+                        auto errorData = static_cast<MapAsyncData*>(func->data);
+                        callback->Reject(context,
+                                         v8::Exception::Error(
+                                                 ConvertToV8String(
+                                                         isolate,
+                                                         errorData->error)));
+                        canvas_native_string_destroy(
+                                errorData->error);
+                        delete errorData;
+                        func->data = nullptr;
+                    }
+                }
+                delete static_cast<PromiseCallback *>(data);
+            }
+    };
+    callback->prepare();
+
+
+    canvas_native_webgpu_buffer_map_async(ptr->GetGPUBuffer(), mode == 1 ? GPUMapMode::GPUMapModeRead : GPUMapMode::GPUMapModeWrite, offset, size,
+                                          [](enum CanvasGPUErrorType type, char *error, void *data) {
+                                              if (data != nullptr) {
+                                                  auto async_data = static_cast<PromiseCallback *>(data);
+                                                  auto inner = async_data->inner_.get();
+                                                  if (inner != nullptr) {
+                                                      if(error != nullptr){
+                                                          inner->data = new MapAsyncData {
+                                                              type, error
+                                                          };
+                                                      }
+                                                      async_data->execute(true);
+                                                  }
+                                              }
+                                          }, callback);
+}
+
+void GPUBufferImpl::GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    GPUBufferImpl *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+    int64_t offset = -1;
+    int64_t size = -1;
+
+    auto offsetVal = args[0];
+    if (offsetVal->IsNumber()) {
+        offset = (int64_t) offsetVal.As<v8::Number>()->Value();
+    }
+
+    auto sizeVal = args[1];
+
+    if (sizeVal->IsNumber()) {
+        size = (int64_t) sizeVal.As<v8::Number>()->Value();
+    }
+
+    auto buf = canvas_native_webgpu_buffer_get_mapped_range(ptr->GetGPUBuffer(), offset, size);
+    auto isolate = args.GetIsolate();
+    if (buf == nullptr) {
+        args.GetReturnValue().Set(v8::ArrayBuffer::New(isolate, 0));
+    } else {
+        auto store = v8::ArrayBuffer::NewBackingStore(buf, size, [](void *data, size_t length,
+                                                                    void *deleter_data) {
+
+                                                                 }, nullptr);
+        auto ab = v8::ArrayBuffer::New(isolate, std::move(store));
+        args.GetReturnValue().Set(ab);
+    }
+}
+
+
+void
+GPUBufferImpl::GetLabel(v8::Local<v8::Name> name,
+                                 const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto label = canvas_native_webgpu_buffer_get_label(ptr->buffer_);
+        if (label == nullptr) {
+            info.GetReturnValue().SetEmptyString();
+            return;
+        }
+        info.GetReturnValue().Set(
+                ConvertToV8String(info.GetIsolate(), label)
+        );
+        canvas_native_string_destroy(label);
+        return;
+    }
+
+    info.GetReturnValue().SetEmptyString();
+}

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

@@ -0,0 +1,63 @@
+//
+// Created by Osei Fortune on 18/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUBUFFERIMPL_H
+#define CANVAS_ANDROID_GPUBUFFERIMPL_H
+
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+
+class GPUBufferImpl : ObjectWrapperImpl {
+public:
+    explicit GPUBufferImpl(const CanvasGPUBuffer *buffer);
+
+    ~GPUBufferImpl() {
+        canvas_native_webgpu_buffer_release(this->GetGPUBuffer());
+    }
+
+    const CanvasGPUBuffer *GetGPUBuffer();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUBufferImpl *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, GPUBufferImpl *buffer) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUBufferImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(buffer, NativeType::GPUBuffer);
+        object->SetAlignedPointerInInternalField(0, buffer);
+        buffer->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void GetUsage(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetSize(v8::Local<v8::Name> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+    static void Destroy(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UnMap(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void MapAsync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetMappedRange(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetLabel(v8::Local<v8::Name> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
+
+
+private:
+    const CanvasGPUBuffer *buffer_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUBUFFERIMPL_H