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

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

@@ -0,0 +1,85 @@
+//
+// Created by Osei Fortune on 01/07/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPURENDERPASSENCODERIMPL_H
+#define CANVAS_ANDROID_GPURENDERPASSENCODERIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPURenderPassEncoderImpl : ObjectWrapperImpl {
+public:
+    GPURenderPassEncoderImpl(const CanvasGPURenderPassEncoder *pass);
+
+    ~GPURenderPassEncoderImpl() {
+        canvas_native_webgpu_render_pass_encoder_release(this->GetPass());
+    }
+
+    const CanvasGPURenderPassEncoder *GetPass();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPURenderPassEncoderImpl *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, GPURenderPassEncoderImpl *encoder) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPURenderPassEncoderImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPURenderPassEncoder);
+        object->SetAlignedPointerInInternalField(0, encoder);
+        encoder->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+    static void BeginOcclusionQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    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 End(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EndOcclusionQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ExecuteBundles(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 SetBlendConstant(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 SetScissorRect(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetStencilReference(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetVertexBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SetViewport(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+
+private:
+    const CanvasGPURenderPassEncoder *pass_;
+    bool ended_ = false;
+};
+
+
+#endif //CANVAS_ANDROID_GPURENDERPASSENCODERIMPL_H

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

@@ -0,0 +1,84 @@
+//
+// Created by Osei Fortune on 29/06/2024.
+//
+
+#include "GPURenderPipelineImpl.h"
+#include "Caches.h"
+#include "GPUBindGroupLayoutImpl.h"
+
+GPURenderPipelineImpl::GPURenderPipelineImpl(const CanvasGPURenderPipeline *pipeline) : pipeline_(
+        pipeline) {}
+
+const CanvasGPURenderPipeline *GPURenderPipelineImpl::GetGPUPipeline() {
+    return this->pipeline_;
+}
+
+
+void GPURenderPipelineImpl::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, "GPURenderPipeline"), func).FromJust();;
+}
+
+GPURenderPipelineImpl *GPURenderPipelineImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPURenderPipelineImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPURenderPipelineImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPURenderPipelineTmpl.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, "GPURenderPipeline"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getBindGroupLayout"),
+            v8::FunctionTemplate::New(isolate, &GetBindGroupLayout));
+
+    cache->GPURenderPipelineTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+void GPURenderPipelineImpl::GetBindGroupLayout(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto index = args[0]->Uint32Value(context).ToChecked();
+
+
+    auto group_layout = canvas_native_webgpu_render_pipeline_get_bind_group_layout(
+            ptr->GetGPUPipeline(), index);
+
+    if (group_layout != nullptr) {
+        auto ret = GPUBindGroupLayoutImpl::NewInstance(isolate,
+                                                       new GPUBindGroupLayoutImpl(group_layout));
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    args.GetReturnValue().SetUndefined();
+}
+

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

@@ -0,0 +1,49 @@
+//
+// Created by Osei Fortune on 29/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPURENDERPIPELINEIMPL_H
+#define CANVAS_ANDROID_GPURENDERPIPELINEIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPURenderPipelineImpl : ObjectWrapperImpl {
+public:
+    explicit GPURenderPipelineImpl(const CanvasGPURenderPipeline *pipeline);
+
+    ~GPURenderPipelineImpl() {
+        canvas_native_webgpu_render_pipeline_release(this->pipeline_);
+    }
+
+    const CanvasGPURenderPipeline *GetGPUPipeline();
+
+    static void Init(v8::Local <v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPURenderPipelineImpl *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, GPURenderPipelineImpl *pipeline) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPURenderPipelineImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPURenderPipeline);
+        object->SetAlignedPointerInInternalField(0, pipeline);
+        pipeline->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+
+    static void GetBindGroupLayout(const v8::FunctionCallbackInfo <v8::Value> &args);
+
+
+private:
+    const CanvasGPURenderPipeline *pipeline_;
+};
+
+
+#endif //CANVAS_ANDROID_GPURENDERPIPELINEIMPL_H

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

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

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

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

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

@@ -0,0 +1,56 @@
+//
+// Created by Osei Fortune on 23/06/2024.
+//
+
+#include "GPUShaderModuleImpl.h"
+#include "Caches.h"
+
+GPUShaderModuleImpl::GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule) : shaderModule_(
+        shaderModule) {}
+
+const CanvasGPUShaderModule *GPUShaderModuleImpl::GetShaderModule() {
+    return this->shaderModule_;
+}
+
+
+void GPUShaderModuleImpl::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, "GPUShaderModule"), func).FromJust();;
+}
+
+GPUShaderModuleImpl *GPUShaderModuleImpl::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetAlignedPointerFromInternalField(0);
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<GPUShaderModuleImpl *>(ptr);
+}
+
+v8::Local<v8::FunctionTemplate> GPUShaderModuleImpl::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->GPUShaderModuleTmpl.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, "GPUShaderModule"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(2);
+
+
+    cache->GPUShaderModuleTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+

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

@@ -0,0 +1,45 @@
+//
+// Created by Osei Fortune on 23/06/2024.
+//
+
+#ifndef CANVAS_ANDROID_GPUSHADERMODULEIMPL_H
+#define CANVAS_ANDROID_GPUSHADERMODULEIMPL_H
+
+#include "Common.h"
+#include "Helpers.h"
+#include "ObjectWrapperImpl.h"
+
+class GPUShaderModuleImpl : ObjectWrapperImpl {
+public:
+    GPUShaderModuleImpl(const CanvasGPUShaderModule *shaderModule);
+
+    ~GPUShaderModuleImpl() {
+        canvas_native_webgpu_shader_module_release(this->GetShaderModule());
+    }
+
+    const CanvasGPUShaderModule *GetShaderModule();
+
+    static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
+
+    static GPUShaderModuleImpl *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, GPUShaderModuleImpl *shaderModule) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = GPUShaderModuleImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(object, NativeType::GPUShaderModule);
+        object->SetAlignedPointerInInternalField(0, shaderModule);
+        shaderModule->BindFinalizer(isolate, object);
+        return scope.Escape(object);
+    }
+
+private:
+    const CanvasGPUShaderModule *shaderModule_;
+};
+
+
+#endif //CANVAS_ANDROID_GPUSHADERMODULEIMPL_H