@shopify/react-native-skia 2.5.1 → 2.5.3

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -0,0 +1,229 @@
+#pragma once
+
+#include <memory>
+#include <shared_mutex>
+#include <unordered_map>
+#include <utility>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+struct NativeInfo {
+  void *nativeSurface;
+  int width;
+  int height;
+};
+
+struct Size {
+  int width;
+  int height;
+};
+
+class SurfaceInfo {
+public:
+  SurfaceInfo(wgpu::Instance gpu, int width, int height)
+      : gpu(std::move(gpu)), width(width), height(height) {}
+
+  ~SurfaceInfo() { surface = nullptr; }
+
+  void reconfigure(int newWidth, int newHeight) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    config.width = newWidth;
+    config.height = newHeight;
+    _configure();
+  }
+
+  void configure(wgpu::SurfaceConfiguration &newConfig) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    config = newConfig;
+    config.width = width;
+    config.height = height;
+    config.presentMode = wgpu::PresentMode::Fifo;
+    _configure();
+  }
+
+  void unconfigure() {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    if (surface) {
+      surface.Unconfigure();
+    } else {
+      texture = nullptr;
+    }
+  }
+
+  void *switchToOffscreen() {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    // We only do this if the onscreen surface is configured.
+    auto isConfigured = config.device != nullptr;
+    if (isConfigured) {
+      wgpu::TextureDescriptor textureDesc;
+      textureDesc.usage = wgpu::TextureUsage::RenderAttachment |
+                          wgpu::TextureUsage::CopySrc |
+                          wgpu::TextureUsage::TextureBinding;
+      textureDesc.format = config.format;
+      textureDesc.size.width = config.width;
+      textureDesc.size.height = config.height;
+      texture = config.device.CreateTexture(&textureDesc);
+    }
+    surface = nullptr;
+    return nativeSurface;
+  }
+
+  void switchToOnscreen(void *newNativeSurface, wgpu::Surface newSurface) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    nativeSurface = newNativeSurface;
+    surface = std::move(newSurface);
+    // If we are comming from an offscreen context, we need to configure the new
+    // surface
+    if (texture != nullptr) {
+      config.usage = config.usage | wgpu::TextureUsage::CopyDst;
+      _configure();
+      // We flush the offscreen texture to the onscreen one
+      wgpu::CommandEncoderDescriptor encoderDesc;
+      auto device = config.device;
+      wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc);
+
+      wgpu::TexelCopyTextureInfo sourceTexture = {};
+      sourceTexture.texture = texture;
+
+      wgpu::TexelCopyTextureInfo destinationTexture = {};
+      wgpu::SurfaceTexture surfaceTexture;
+      surface.GetCurrentTexture(&surfaceTexture);
+      destinationTexture.texture = surfaceTexture.texture;
+
+      wgpu::Extent3D size = {sourceTexture.texture.GetWidth(),
+                             sourceTexture.texture.GetHeight(),
+                             sourceTexture.texture.GetDepthOrArrayLayers()};
+
+      encoder.CopyTextureToTexture(&sourceTexture, &destinationTexture, &size);
+
+      wgpu::CommandBuffer commands = encoder.Finish();
+      wgpu::Queue queue = device.GetQueue();
+      queue.Submit(1, &commands);
+      surface.Present();
+      texture = nullptr;
+    }
+  }
+
+  void resize(int newWidth, int newHeight) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    width = newWidth;
+    height = newHeight;
+  }
+
+  void present() {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    if (surface) {
+      surface.Present();
+    }
+  }
+
+  wgpu::Texture getCurrentTexture() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    if (surface) {
+      wgpu::SurfaceTexture surfaceTexture;
+      surface.GetCurrentTexture(&surfaceTexture);
+      return surfaceTexture.texture;
+    } else {
+      return texture;
+    }
+  }
+
+  NativeInfo getNativeInfo() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return {.nativeSurface = nativeSurface, .width = width, .height = height};
+  }
+
+  Size getSize() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return {.width = width, .height = height};
+  }
+
+  wgpu::SurfaceConfiguration getConfig() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return config;
+  }
+
+  wgpu::Device getDevice() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return config.device;
+  }
+
+private:
+  void _configure() {
+    if (surface) {
+      surface.Configure(&config);
+    } else {
+      wgpu::TextureDescriptor textureDesc;
+      textureDesc.format = config.format;
+      textureDesc.size.width = config.width;
+      textureDesc.size.height = config.height;
+      textureDesc.usage = wgpu::TextureUsage::RenderAttachment |
+                          wgpu::TextureUsage::CopySrc |
+                          wgpu::TextureUsage::TextureBinding;
+      texture = config.device.CreateTexture(&textureDesc);
+    }
+  }
+
+  mutable std::shared_mutex _mutex;
+  void *nativeSurface = nullptr;
+  wgpu::Surface surface = nullptr;
+  wgpu::Texture texture = nullptr;
+  wgpu::Instance gpu;
+  wgpu::SurfaceConfiguration config;
+  int width;
+  int height;
+};
+
+class SurfaceRegistry {
+public:
+  static SurfaceRegistry &getInstance() {
+    static SurfaceRegistry instance;
+    return instance;
+  }
+
+  SurfaceRegistry(const SurfaceRegistry &) = delete;
+  SurfaceRegistry &operator=(const SurfaceRegistry &) = delete;
+
+  std::shared_ptr<SurfaceInfo> getSurfaceInfo(int id) {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    auto it = _registry.find(id);
+    if (it != _registry.end()) {
+      return it->second;
+    }
+    return nullptr;
+  }
+
+  void removeSurfaceInfo(int id) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    _registry.erase(id);
+  }
+
+  std::shared_ptr<SurfaceInfo> addSurfaceInfo(int id, wgpu::Instance gpu,
+                                              int width, int height) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    auto info = std::make_shared<SurfaceInfo>(gpu, width, height);
+    _registry[id] = info;
+    return info;
+  }
+
+  std::shared_ptr<SurfaceInfo>
+  getSurfaceInfoOrCreate(int id, wgpu::Instance gpu, int width, int height) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    auto it = _registry.find(id);
+    if (it != _registry.end()) {
+      return it->second;
+    }
+    auto info = std::make_shared<SurfaceInfo>(gpu, width, height);
+    _registry[id] = info;
+    return info;
+  }
+
+private:
+  SurfaceRegistry() = default;
+  mutable std::shared_mutex _mutex;
+  std::unordered_map<int, std::shared_ptr<SurfaceInfo>> _registry;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -10,6 +10,9 @@
 #include "Convertors.h"
 
 #include "GPUFeatures.h"
+#include "GPUInternalError.h"
+#include "GPUOutOfMemoryError.h"
+#include "GPUValidationError.h"
 #include "jsi2/JSIConverter.h"
 
 namespace rnwgpu {
@@ -73,6 +76,29 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
                                  std::string(message.data, message.length)
                            : "no message";
     fprintf(stderr, "%s", fullMessage.c_str());
+
+    // Look up the GPUDevice from the registry and notify it
+    auto *gpuDevice = GPUDeviceRegistry::getInstance().getDevice(device.Get());
+    if (gpuDevice != nullptr) {
+      std::string messageStr =
+          message.length > 0 ? std::string(message.data, message.length) : "";
+
+      GPUErrorVariant error;
+      switch (type) {
+      case wgpu::ErrorType::Validation:
+        error = std::make_shared<GPUValidationError>(messageStr);
+        break;
+      case wgpu::ErrorType::OutOfMemory:
+        error = std::make_shared<GPUOutOfMemoryError>(messageStr);
+        break;
+      case wgpu::ErrorType::Internal:
+      case wgpu::ErrorType::Unknown:
+      default:
+        error = std::make_shared<GPUInternalError>(messageStr);
+        break;
+      }
+      gpuDevice->notifyUncapturedError(std::move(error));
+    }
   });
   std::string label =
       descriptor.has_value() ? descriptor.value()->label.value_or("") : "";

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -0,0 +1,64 @@
+#include "GPUCanvasContext.h"
+#include "Convertors.h"
+#include <memory>
+
+#ifdef __APPLE__
+namespace dawn::native::metal {
+
+void WaitForCommandsToBeScheduled(WGPUDevice device);
+
+}
+#endif
+
+namespace rnwgpu {
+
+void GPUCanvasContext::configure(
+    std::shared_ptr<GPUCanvasConfiguration> configuration) {
+  Convertor conv;
+  wgpu::SurfaceConfiguration surfaceConfiguration;
+  surfaceConfiguration.device = configuration->device->get();
+  if (configuration->viewFormats.has_value()) {
+    if (!conv(surfaceConfiguration.viewFormats,
+              surfaceConfiguration.viewFormatCount,
+              configuration->viewFormats.value())) {
+      throw std::runtime_error("Error with SurfaceConfiguration");
+    }
+  }
+  if (!conv(surfaceConfiguration.usage, configuration->usage) ||
+      !conv(surfaceConfiguration.format, configuration->format)) {
+    throw std::runtime_error("Error with SurfaceConfiguration");
+  }
+
+#ifdef __APPLE__
+  surfaceConfiguration.alphaMode = configuration->alphaMode;
+#endif
+  surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo;
+  _surfaceInfo->configure(surfaceConfiguration);
+}
+
+void GPUCanvasContext::unconfigure() {}
+
+std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
+  auto prevSize = _surfaceInfo->getConfig();
+  auto width = _canvas->getWidth();
+  auto height = _canvas->getHeight();
+  auto sizeHasChanged = prevSize.width != width || prevSize.height != height;
+  if (sizeHasChanged) {
+    _surfaceInfo->reconfigure(width, height);
+  }
+  auto texture = _surfaceInfo->getCurrentTexture();
+  return std::make_shared<GPUTexture>(texture, "");
+}
+
+void GPUCanvasContext::present() {
+#ifdef __APPLE__
+  dawn::native::metal::WaitForCommandsToBeScheduled(
+      _surfaceInfo->getDevice().Get());
+#endif
+  auto size = _surfaceInfo->getSize();
+  _canvas->setClientWidth(size.width);
+  _canvas->setClientHeight(size.height);
+  _surfaceInfo->present();
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "descriptors/Unions.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/NativeObject.h"
+
+#include "rnwgpu/Canvas.h"
+#include "GPU.h"
+#include "descriptors/GPUCanvasConfiguration.h"
+#include "GPUTexture.h"
+#include "rnwgpu/SurfaceRegistry.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUCanvasContext : public NativeObject<GPUCanvasContext> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUCanvasContext";
+
+  GPUCanvasContext(std::shared_ptr<GPU> gpu, int contextId, int width,
+                   int height)
+      : NativeObject(CLASS_NAME), _gpu(std::move(gpu)) {
+    _canvas = std::make_shared<Canvas>(nullptr, width, height);
+    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+    _surfaceInfo =
+        registry.getSurfaceInfoOrCreate(contextId, _gpu->get(), width, height);
+  }
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::shared_ptr<Canvas> getCanvas() { return _canvas; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUCanvasContext::getBrand);
+    installGetter(runtime, prototype, "canvas", &GPUCanvasContext::getCanvas);
+    installMethod(runtime, prototype, "configure",
+                  &GPUCanvasContext::configure);
+    installMethod(runtime, prototype, "unconfigure",
+                  &GPUCanvasContext::unconfigure);
+    installMethod(runtime, prototype, "getCurrentTexture",
+                  &GPUCanvasContext::getCurrentTexture);
+    installMethod(runtime, prototype, "present", &GPUCanvasContext::present);
+  }
+
+  inline const wgpu::Surface get() { return nullptr; }
+  void configure(std::shared_ptr<GPUCanvasConfiguration> configuration);
+  void unconfigure();
+  std::shared_ptr<GPUTexture> getCurrentTexture();
+  void present();
+
+private:
+  std::shared_ptr<Canvas> _canvas;
+  std::shared_ptr<SurfaceInfo> _surfaceInfo;
+  std::shared_ptr<GPU> _gpu;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -431,4 +431,56 @@ async::AsyncTaskHandle GPUDevice::getLost() {
   _lostHandle = handle;
   return handle;
 }
+void GPUDevice::addEventListener(std::string type, jsi::Function callback) {
+  std::lock_guard<std::mutex> lock(_listenersMutex);
+  auto sharedCallback = std::make_shared<jsi::Function>(std::move(callback));
+  _eventListeners[type].push_back(sharedCallback);
+}
+
+void GPUDevice::removeEventListener(std::string type, jsi::Function callback) {
+  std::lock_guard<std::mutex> lock(_listenersMutex);
+  auto it = _eventListeners.find(type);
+  if (it != _eventListeners.end()) {
+    auto &listeners = it->second;
+    // Remove the last listener of this type (simple approach since we can't
+    // easily compare jsi::Function objects)
+    if (!listeners.empty()) {
+      listeners.pop_back();
+    }
+  }
+}
+
+void GPUDevice::notifyUncapturedError(GPUErrorVariant error) {
+  auto runtime = getCreationRuntime();
+  if (runtime == nullptr) {
+    return;
+  }
+
+  std::vector<std::shared_ptr<jsi::Function>> listeners;
+  {
+    std::lock_guard<std::mutex> lock(_listenersMutex);
+    auto it = _eventListeners.find("uncapturederror");
+    if (it != _eventListeners.end()) {
+      listeners = it->second;
+    }
+  }
+
+  if (listeners.empty()) {
+    return;
+  }
+
+  // Create the event object
+  auto event = std::make_shared<GPUUncapturedErrorEvent>(std::move(error));
+  auto eventValue = GPUUncapturedErrorEvent::create(*runtime, event);
+
+  // Call all listeners
+  for (const auto &listener : listeners) {
+    try {
+      listener->call(*runtime, eventValue);
+    } catch (const std::exception &e) {
+      fprintf(stderr, "Error in uncapturederror listener: %s\n", e.what());
+    }
+  }
+}
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.h

@@ -1,11 +1,15 @@
 #pragma once
 
+#include <functional>
+#include <map>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
 #include <unordered_set>
 #include <utility>
 #include <variant>
+#include <vector>
 
 #include "descriptors/Unions.h"
 
@@ -16,6 +20,8 @@
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUUncapturedErrorEvent.h"
+
 #include "GPUBindGroup.h"
 #include "GPUBindGroupLayout.h"
 #include "GPUBuffer.h"
@@ -51,6 +57,39 @@ namespace rnwgpu {
 
 namespace jsi = facebook::jsi;
 
+// Forward declaration
+class GPUDevice;
+
+// Static registry to map wgpu::Device handles to GPUDevice instances
+class GPUDeviceRegistry {
+public:
+  static GPUDeviceRegistry &getInstance() {
+    static GPUDeviceRegistry instance;
+    return instance;
+  }
+
+  void registerDevice(WGPUDevice handle, GPUDevice *device) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    _devices[handle] = device;
+  }
+
+  void unregisterDevice(WGPUDevice handle) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    _devices.erase(handle);
+  }
+
+  GPUDevice *getDevice(WGPUDevice handle) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    auto it = _devices.find(handle);
+    return it != _devices.end() ? it->second : nullptr;
+  }
+
+private:
+  GPUDeviceRegistry() = default;
+  std::mutex _mutex;
+  std::map<WGPUDevice, GPUDevice *> _devices;
+};
+
 class GPUDevice : public NativeObject<GPUDevice> {
 public:
   static constexpr const char *CLASS_NAME = "GPUDevice";
@@ -59,7 +98,15 @@ public:
                      std::shared_ptr<async::AsyncRunner> async,
                      std::string label)
       : NativeObject(CLASS_NAME), _instance(instance), _async(async),
-        _label(label) {}
+        _label(label) {
+    // Register this device in the global registry
+    GPUDeviceRegistry::getInstance().registerDevice(_instance.Get(), this);
+  }
+
+  ~GPUDevice() {
+    // Unregister from the global registry
+    GPUDeviceRegistry::getInstance().unregisterDevice(_instance.Get());
+  }
 
 public:
   std::string getBrand() { return CLASS_NAME; }
@@ -105,6 +152,11 @@ public:
   void notifyDeviceLost(wgpu::DeviceLostReason reason, std::string message);
   void forceLossForTesting();
 
+  // Event listener methods
+  void addEventListener(std::string type, jsi::Function callback);
+  void removeEventListener(std::string type, jsi::Function callback);
+  void notifyUncapturedError(GPUErrorVariant error);
+
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
     _label = label;
@@ -155,6 +207,10 @@ public:
                         &GPUDevice::setLabel);
     installMethod(runtime, prototype, "forceLossForTesting",
                   &GPUDevice::forceLossForTesting);
+    installMethod(runtime, prototype, "addEventListener",
+                  &GPUDevice::addEventListener);
+    installMethod(runtime, prototype, "removeEventListener",
+                  &GPUDevice::removeEventListener);
   }
 
   inline const wgpu::Device get() { return _instance; }
@@ -169,6 +225,11 @@ private:
   std::shared_ptr<GPUDeviceLostInfo> _lostInfo;
   bool _lostSettled = false;
   std::optional<async::AsyncTaskHandle::ResolveFunction> _lostResolve;
+
+  // Event listeners storage
+  std::mutex _listenersMutex;
+  std::map<std::string, std::vector<std::shared_ptr<jsi::Function>>>
+      _eventListeners;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUUncapturedErrorEvent.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <variant>
+
+#include "jsi2/NativeObject.h"
+
+#include "GPUError.h"
+#include "GPUInternalError.h"
+#include "GPUOutOfMemoryError.h"
+#include "GPUValidationError.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+using GPUErrorVariant =
+    std::variant<std::shared_ptr<GPUValidationError>,
+                 std::shared_ptr<GPUOutOfMemoryError>,
+                 std::shared_ptr<GPUInternalError>>;
+
+class GPUUncapturedErrorEvent : public NativeObject<GPUUncapturedErrorEvent> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUUncapturedErrorEvent";
+
+  explicit GPUUncapturedErrorEvent(GPUErrorVariant error)
+      : NativeObject(CLASS_NAME), _error(std::move(error)) {}
+
+  GPUErrorVariant getError() { return _error; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "error",
+                  &GPUUncapturedErrorEvent::getError);
+  }
+
+private:
+  GPUErrorVariant _error;
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<GPUErrorVariant> {
+  static jsi::Value toJSI(jsi::Runtime &runtime, GPUErrorVariant arg) {
+    return std::visit(
+        [&runtime](auto &&error) -> jsi::Value {
+          using T = std::decay_t<decltype(error)>;
+          return JSIConverter<T>::toJSI(runtime, error);
+        },
+        arg);
+  }
+
+  static GPUErrorVariant fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                                 bool outOfBounds) {
+    throw std::runtime_error("GPUErrorVariant::fromJSI not implemented");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "jsi2/NativeObject.h"
+
+#include "rnwgpu/Canvas.h"
+#include "GPU.h"
+#include "GPUCanvasContext.h"
+#include "rnwgpu/PlatformContext.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class RNWebGPU : public NativeObject<RNWebGPU> {
+public:
+  static constexpr const char *CLASS_NAME = "RNWebGPU";
+
+  explicit RNWebGPU(std::shared_ptr<GPU> gpu,
+                    std::shared_ptr<PlatformContext> platformContext)
+      : NativeObject(CLASS_NAME), _gpu(gpu), _platformContext(platformContext) {
+  }
+
+  std::shared_ptr<GPU> getGPU() { return _gpu; }
+
+  bool getFabric() { return true; }
+
+  std::shared_ptr<GPUCanvasContext>
+  MakeWebGPUCanvasContext(int contextId, float width, float height) {
+    auto ctx =
+        std::make_shared<GPUCanvasContext>(_gpu, contextId, width, height);
+    return ctx;
+  }
+
+  std::shared_ptr<Canvas> getNativeSurface(int contextId) {
+    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+    auto info = registry.getSurfaceInfo(contextId);
+    if (info == nullptr) {
+      return std::make_shared<Canvas>(nullptr, 0, 0);
+    }
+    auto nativeInfo = info->getNativeInfo();
+    return std::make_shared<Canvas>(nativeInfo.nativeSurface, nativeInfo.width,
+                                    nativeInfo.height);
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "fabric", &RNWebGPU::getFabric);
+    installGetter(runtime, prototype, "gpu", &RNWebGPU::getGPU);
+    installMethod(runtime, prototype, "getNativeSurface",
+                  &RNWebGPU::getNativeSurface);
+    installMethod(runtime, prototype, "MakeWebGPUCanvasContext",
+                  &RNWebGPU::MakeWebGPUCanvasContext);
+  }
+
+private:
+  std::shared_ptr<GPU> _gpu;
+  std::shared_ptr<PlatformContext> _platformContext;
+};
+
+} // namespace rnwgpu