@nativescript/canvas 2.0.0-webgpu.3 → 2.0.0-webgpu.31

package/platforms/ios/src/cpp/ImageAssetImpl.cpp

@@ -11,7 +11,7 @@
 #include "Helpers.h"
 #include "Common.h"
 
-ImageAssetImpl::ImageAssetImpl(ImageAsset *asset) : asset_(asset) {
+ImageAssetImpl::ImageAssetImpl(const ImageAsset *asset) : asset_(asset) {
 }
 
 ImageAssetImpl::~ImageAssetImpl() {
@@ -240,7 +240,7 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -269,8 +269,6 @@ void ImageAssetImpl::FromUrlCb(const v8::FunctionCallbackInfo<v8::Value> &args)
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
 
     std::thread thread(
             [jsi_callback, asset](
@@ -412,19 +410,17 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
     auto path = ConvertFromV8String(isolate, args[0]);
 
-    auto asset = canvas_native_image_asset_reference(
-            ptr->GetImageAsset());
+    auto asset = canvas_native_image_asset_reference(ptr->GetImageAsset());
 
     auto callback = args[1].As<v8::Function>();
 
-
     auto jsi_callback = new JSICallback(isolate, callback);
 
 #ifdef __ANDROID__
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -443,7 +439,7 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
 
                       v8::Local<v8::Value> args[1] = {v8::Boolean::New(isolate, done)};
 
-                      // v8::TryCatch tc(isolate);
+                       v8::TryCatch tc(isolate);
 
                       callback->Call(context, context->Global(), 1,
                                      args);  // ignore JS return value
@@ -452,23 +448,23 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
 
     std::thread thread(
             [jsi_callback, asset](
-                    const std::string &path) {
+                    const std::string path) {
 
                 auto done = canvas_native_image_asset_load_from_path(asset, path.c_str());
 
-                canvas_native_image_asset_release(asset);
-
                 write(jsi_callback->fd_[1],
                       &done,
                       sizeof(bool));
 
+                canvas_native_image_asset_release(asset);
+
             }, std::move(path));
 
+    thread.detach();
+
 #endif
 
 
@@ -501,11 +497,9 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
             callback->Call(context, context->Global(), 1,
                            args);  // ignore JS return value
 
-
-            delete jsi_callback;
-            delete queue;
-            delete current_queue;
-
+                           delete queue;
+                           delete current_queue;
+                           delete jsi_callback;
 
         };
 
@@ -514,6 +508,8 @@ void ImageAssetImpl::FromFileCb(const v8::FunctionCallbackInfo<v8::Value> &args)
     };
 
     queue->addOperation(task);
+
+
 #endif
 }
 
@@ -572,7 +568,7 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -600,9 +596,6 @@ void ImageAssetImpl::FromBytesCb(const v8::FunctionCallbackInfo<v8::Value> &args
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
-
     std::thread thread(
             [jsi_callback, asset, data, size]() {
 
@@ -713,7 +706,7 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
     ALooper_addFd(jsi_callback->looper_,
                   jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
+                  0,
                   ALOOPER_EVENT_INPUT,
                   [](int fd, int events,
                      void *data) {
@@ -741,9 +734,6 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
                       return 0;
                   }, jsi_callback);
 
-    ALooper_wake(jsi_callback->looper_);
-
-
     std::thread thread(
             [jsi_callback, asset, format](
                     const std::string &path) {
@@ -813,7 +803,7 @@ void ImageAssetImpl::SaveCb(const v8::FunctionCallbackInfo<v8::Value> &args) {
 }
 */
 
-ImageAsset *ImageAssetImpl::GetImageAsset() {
+const ImageAsset *ImageAssetImpl::GetImageAsset() {
     return this->asset_;
 }
 

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

@@ -19,11 +19,11 @@
 class ImageAssetImpl : ObjectWrapperImpl {
 public:
 
-    explicit ImageAssetImpl(ImageAsset *asset);
+    explicit ImageAssetImpl(const ImageAsset *asset);
 
     ~ImageAssetImpl();
 
-    ImageAsset *GetImageAsset();
+    const ImageAsset *GetImageAsset();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -67,5 +67,5 @@ public:
 
 
 private:
-    ImageAsset *asset_;
+    const ImageAsset *asset_;
 };

package/platforms/ios/src/cpp/ImageBitmapImpl.cpp

@@ -5,10 +5,10 @@
 #include "ImageBitmapImpl.h"
 #include "Caches.h"
 
-ImageBitmapImpl::ImageBitmapImpl(ImageAsset* asset)
+ImageBitmapImpl::ImageBitmapImpl(const ImageAsset *asset)
         : bitmap_(asset) {}
 
-ImageBitmapImpl::~ImageBitmapImpl(){
+ImageBitmapImpl::~ImageBitmapImpl() {
     canvas_native_image_asset_release(bitmap_);
     this->bitmap_ = nullptr;
 }
@@ -26,6 +26,23 @@ void ImageBitmapImpl::Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isol
     canvasModule->Set(context, ConvertToV8String(isolate, "ImageBitmap"), func);
 }
 
+
+void ImageBitmapImpl::FromAsset(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto asset = args[0];
+    auto type = GetNativeType(asset);
+    auto isolate = args.GetIsolate();
+    if (type == NativeType::ImageAsset){
+        auto ptr = ImageAssetImpl::GetPointer(asset.As<v8::Object>());
+        auto ret = canvas_native_image_asset_reference(ptr->GetImageAsset());
+        auto bitmap = new ImageBitmapImpl(ret);
+        auto data = v8::External::New(isolate, bitmap);
+        auto object = ImageBitmapImpl::NewInstance(isolate, data);
+        args.GetReturnValue().Set(object);
+        return;
+    }
+    args.GetReturnValue().SetNull();
+}
+
 ImageBitmapImpl *ImageBitmapImpl::GetPointer(v8::Local<v8::Object> object) {
     auto ptr = object->GetAlignedPointerFromInternalField(0);
     if (ptr == nullptr) {
@@ -45,7 +62,10 @@ v8::Local<v8::FunctionTemplate> ImageBitmapImpl::GetCtor(v8::Isolate *isolate) {
     ctorTmpl->InstanceTemplate()->SetInternalFieldCount(2);
     ctorTmpl->SetClassName(ConvertToV8String(isolate, "ImageBitmap"));
 
+    ctorTmpl->Set(ConvertToV8String(isolate, "fromAsset"), v8::FunctionTemplate::New(isolate, FromAsset));
+
     auto tmpl = ctorTmpl->InstanceTemplate();
+
     tmpl->SetInternalFieldCount(2);
     tmpl->SetAccessor(
             ConvertToV8String(isolate, "width"), GetWidth);
@@ -56,6 +76,13 @@ v8::Local<v8::FunctionTemplate> ImageBitmapImpl::GetCtor(v8::Isolate *isolate) {
     tmpl->Set(
             ConvertToV8String(isolate, "close"), v8::FunctionTemplate::New(isolate, Close));
 
+    tmpl->SetAccessor(
+            ConvertToV8String(isolate, "__addr"),
+            GetAddr);
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "__getRef"),
+            v8::FunctionTemplate::New(isolate, GetReference));
 
     cache->ImageBitmapTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
@@ -93,6 +120,8 @@ void ImageBitmapImpl::Close(const v8::FunctionCallbackInfo<v8::Value> &args) {
         return;
     }
 
+    canvas_native_image_asset_close(ptr->GetImageAsset());
+
     ptr->closed_ = true;
 }
 
@@ -184,6 +213,34 @@ ImageBitmapImpl::HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value>
     return ret;
 }
 
-ImageAsset* ImageBitmapImpl::GetImageAsset() {
+
+void
+ImageBitmapImpl::GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto isolate = info.GetIsolate();
+        auto ret = std::to_string(canvas_native_image_asset_get_addr(ptr->GetImageAsset()));
+        info.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+        return;
+    }
+    info.GetReturnValue().SetEmptyString();
+}
+
+void
+ImageBitmapImpl::GetReference(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto ptr = GetPointer(args.This());
+    if (ptr != nullptr) {
+        auto isolate = args.GetIsolate();
+        auto reference = canvas_native_image_asset_reference(ptr->GetImageAsset());
+        auto ret = std::to_string(canvas_native_image_asset_get_addr(reference));
+        args.GetReturnValue().Set(ConvertToV8String(isolate, ret));
+        return;
+    }
+
+    args.GetReturnValue().SetEmptyString();
+}
+
+const ImageAsset *ImageBitmapImpl::GetImageAsset() {
     return this->bitmap_;
 }

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

@@ -21,7 +21,7 @@ struct Options {
 
 class ImageBitmapImpl : public ObjectWrapperImpl {
 public:
-    explicit ImageBitmapImpl(ImageAsset *asset);
+    explicit ImageBitmapImpl(const ImageAsset *asset);
 
     ~ImageBitmapImpl();
 
@@ -46,7 +46,7 @@ public:
 
     static Options HandleOptions(v8::Isolate *isolate, const v8::Local<v8::Value> &options);
 
-    ImageAsset *GetImageAsset();
+    const ImageAsset *GetImageAsset();
 
     static void Init(v8::Local<v8::Object> canvasModule, v8::Isolate *isolate);
 
@@ -60,9 +60,16 @@ public:
     static void GetHeight(v8::Local<v8::String> name,
                           const v8::PropertyCallbackInfo<v8::Value> &info);
 
+    static void GetReference(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetAddr(v8::Local<v8::String> name,
+                        const v8::PropertyCallbackInfo<v8::Value> &info);
+
     static void Close(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void FromAsset(const v8::FunctionCallbackInfo<v8::Value> &args);
+
 private:
-    ImageAsset *bitmap_;
+    const ImageAsset *bitmap_;
     bool closed_ = false;
 };

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

@@ -163,7 +163,7 @@ struct PromiseCallback {
         auto data = new PromiseCallback(this->inner_);
         ALooper_addFd(looper,
                       fd,
-                      ALOOPER_POLL_CALLBACK,
+                      0,
                       ALOOPER_EVENT_INPUT,
                       [](int fd, int events,
                          void *data) {
@@ -175,7 +175,6 @@ struct PromiseCallback {
                           return 0;
                       }, (void *) data);
 
-        ALooper_wake(looper);
         inner->isPrepared_ = true;
     }
 

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

@@ -630,7 +630,7 @@ void CanvasRenderingContext2DImpl::DrawPoints(const v8::FunctionCallbackInfo<v8:
         }
 
         canvas_native_context_draw_points(
-                ptr->GetContext(), pointMode,
+                ptr->GetContext(), (int32_t)pointMode,
                 store.data(), store.size());
 
 

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

@@ -636,7 +636,7 @@ public:
     static void DrawImage(const v8::FunctionCallbackInfo<v8::Value> &args);
 
     static void
-    DrawImageDxDyAssetImpl(CanvasRenderingContext2DImpl *ptr, ImageAsset *asset, double dx,
+    DrawImageDxDyAssetImpl(CanvasRenderingContext2DImpl *ptr, const ImageAsset *asset, double dx,
                            double dy) {
         if (asset != nullptr) {
             canvas_native_context_draw_image_dx_dy_asset(
@@ -690,7 +690,7 @@ public:
         }
     }
 
-    static void DrawImageDxDyDwDhAssetImpl(CanvasRenderingContext2DImpl *ptr, ImageAsset *asset,
+    static void DrawImageDxDyDwDhAssetImpl(CanvasRenderingContext2DImpl *ptr, const ImageAsset *asset,
                                            double dx, double dy, double dw, double dh) {
 
 
@@ -783,7 +783,7 @@ public:
 
     static void
     DrawImageAssetImpl(CanvasRenderingContext2DImpl *ptr,
-                       ImageAsset *asset, double sx,
+                       const ImageAsset *asset, double sx,
                        double sy, double sw, double sh, double dx, double dy, double dw,
                        double dh) {
 

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

@@ -199,7 +199,7 @@ public:
                             double rotation,
                             double start_angle,
                             double end_angle,
-                            double anticlockwise) {
+                            bool anticlockwise) {
 
         canvas_native_path_ellipse(
                 receiver_obj,
@@ -222,7 +222,7 @@ public:
                             double rotation,
                             double start_angle,
                             double end_angle,
-                            double anticlockwise) {
+                            bool anticlockwise) {
         Path2D *ptr = GetPointer(receiver_obj);
         if (ptr == nullptr) {
             return;
@@ -362,9 +362,9 @@ public:
 
                 canvas_native_path_round_rect(
                         ptr->GetPath(),
-                        x, y,
-                        width,
-                        height, buf.data(),
+                        (float)x, (float)y,
+                        (float)width,
+                        (float)height, buf.data(),
                         buf.size());
 
             }

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

@@ -4350,8 +4350,113 @@ WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &arg
                     ptr->GetState()
             );
             return;
-        }
+        } else {
+            auto objectType = GetNativeType(value);
+
+            switch (objectType) {
+                case NativeType::ImageAsset: {
+                    auto image_asset = ImageAssetImpl::GetPointer(value.As<v8::Object>());
+
+                    if (image_asset !=
+                        nullptr) {
+
+                        canvas_native_webgl2_tex_image2d_image_asset(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_asset->GetImageAsset(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::ImageBitmap: {
+                    auto image_bitmap = ImageBitmapImpl::GetPointer(value.As<v8::Object>());
+
+                    if (image_bitmap !=
+                        nullptr) {
+                        canvas_native_webgl2_tex_image2d_image_asset(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_bitmap->GetImageAsset(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::CanvasRenderingContext2D: {
+                    auto canvas_2d = CanvasRenderingContext2DImpl::GetPointer(
+                            value.As<v8::Object>());
+
+                    if (canvas_2d != nullptr) {
+                        canvas_native_webgl2_tex_image2d_canvas2d(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                canvas_2d->GetContext(),
+                                ptr->GetState()
+                        );
+                    }
+
+                    return;
+                }
+                case NativeType::WebGLRenderingContextBase: {
+                    auto gl = WebGLRenderingContext::GetPointer(value.As<v8::Object>());
+
+                    if (gl != nullptr) {
+                        canvas_native_webgl2_tex_image2d_webgl(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                gl->GetState(),
+                                ptr->GetState()
+                        );
+                    }
+                    return;
+                }
+                case NativeType::ImageData: {
+                    auto image_data = ImageDataImpl::GetPointer(value.As<v8::Object>());
+                    if (image_data != nullptr) {
+                        canvas_native_webgl2_tex_image2d_image_data(
+                                target,
+                                level,
+                                internalformat,
+                                width,
+                                height,
+                                border,
+                                format,
+                                type,
+                                image_data->GetImageData(),
+                                ptr->GetState()
+                        );
+                    }
 
+                }
+                default:
+                    break;
+            }
+        }
     }
 }
 

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

@@ -4,7 +4,7 @@
 
 #include "GPUAdapterImpl.h"
 #include "Caches.h"
-
+#include "GPULabel.h"
 GPUAdapterImpl::GPUAdapterImpl(const CanvasGPUAdapter *adapter) : adapter_(adapter) {}
 
 const CanvasGPUAdapter *GPUAdapterImpl::GetGPUAdapter() {
@@ -61,7 +61,6 @@ v8::Local<v8::FunctionTemplate> GPUAdapterImpl::GetCtor(v8::Isolate *isolate) {
             GetLimits
     );
 
-
     tmpl->Set(
             ConvertToV8String(isolate, "requestAdapterInfo"),
             v8::FunctionTemplate::New(isolate, &RequestAdapterInfo));
@@ -90,19 +89,19 @@ GPUAdapterImpl::GetFeatures(v8::Local<v8::Name> name,
 
         auto len = canvas_native_string_buffer_get_length(features);
 
-        auto map = v8::Map::New(isolate);
+        auto set = v8::Set::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);
+                auto keyValue = ConvertToV8String(isolate, (char *) item);
+                set->Add(context, keyValue);
                 canvas_native_string_destroy(item);
             }
 
         }
         canvas_native_string_buffer_release(features);
 
-        info.GetReturnValue().Set(map);
+        info.GetReturnValue().Set(set);
 
         return;
     }
@@ -162,11 +161,14 @@ struct RequestData {
     char *error_;
     const CanvasGPUDevice *device_;
     char **required_features_data_;
+    size_t required_features_data_size;
 
     ~RequestData() {
         if (required_features_data_ != nullptr) {
-            delete[] required_features_data_;
-            required_features_data_ = nullptr;
+            for (size_t i = 0; i < required_features_data_size; ++i) {
+                    delete[] required_features_data_[i];
+                }
+                delete[] required_features_data_;
         }
 
         if (error_ != nullptr) {
@@ -190,7 +192,7 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
 
     auto func = cb.As<v8::Function>();
 
-    std::string label;
+    GPULabel label;
 
     std::vector<std::string> required_features_buf;
 
@@ -201,10 +203,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         v8::Local<v8::Value> labelValue;
         options->Get(context, ConvertToV8String(isolate, "label")).ToLocal(
                 &labelValue);
+        
+        label = GPULabel(isolate, labelValue);
 
-        if (!labelValue.IsEmpty() && labelValue->IsString()) {
-            label = ConvertFromV8String(isolate, labelValue);
-        }
 
         v8::Local<v8::Value> requiredFeaturesValue;
 
@@ -212,11 +213,9 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                 &requiredFeaturesValue);
 
 
-        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsSet()) {
-            v8::Local<v8::Set> requiredFeaturesSet = requiredFeaturesValue.As<v8::Set>();
-            v8::Local<v8::Array> requiredFeatures = requiredFeaturesSet->AsArray();
+        if (!requiredFeaturesValue.IsEmpty() && requiredFeaturesValue->IsArray()) {
+            v8::Local<v8::Array> requiredFeatures = requiredFeaturesValue.As<v8::Array>();
             auto len = requiredFeatures->Length();
-
             for (int i = 0; i < len; i++) {
                 auto item = requiredFeatures->Get(context, i);
                 if (!item.IsEmpty()) {
@@ -245,10 +244,12 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
     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];
+        required_features_data = new char *[required_features_data_length];
 
         for (size_t i = 0; i < required_features_data_length; ++i) {
-            std::strcpy(required_features_data[i], required_features_buf[i].c_str());
+            required_features_data[i] = new char[required_features_buf[i].size() + 1];
+            auto src = required_features_buf[i].c_str();
+            std::strcpy(required_features_data[i], src);
         }
     }
 
@@ -297,7 +298,8 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                             callback->Call(context, context->Global(),
                                            1,
                                            args);  // ignore JS return value
-                            delete static_cast<AsyncCallback *>(data);
+                            
+                            
                         } else {
 
                             auto impl = new GPUDeviceImpl(requestData->device_);
@@ -311,14 +313,14 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
                             callback->Call(context, context->Global(),
                                            2,
                                            args);  // ignore JS return value
-
-                            delete static_cast<AsyncCallback *>(data);
                         }
 
                         if (requestData != nullptr) {
                             delete requestData;
                             requestData = nullptr;
                         }
+
+                        delete static_cast<AsyncCallback *>(data);
                     }
                 }
             }
@@ -330,14 +332,15 @@ void GPUAdapterImpl::RequestDevice(const v8::FunctionCallbackInfo<v8::Value> &ar
         inner->data = new RequestData{
                 nullptr,
                 nullptr,
-                required_features_data
+                required_features_data,
+                required_features_data_length
         };
     }
 
     callback->prepare();
 
     canvas_native_webgpu_adapter_request_device(ptr->GetGPUAdapter(),
-                                                label.empty() ? nullptr : label.c_str(),
+                                                *label,
                                                 required_features_data,
                                                 required_features_data_length,
                                                 limits,