react-native-wgpu 0.5.11 → 0.5.14

package/cpp/rnwgpu/api/GPUOrigin2D.h

@@ -1,55 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "JSIConverter.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-struct GPUOrigin2D {
-  double x = 0;
-  double y = 0;
-};
-
-template <> struct JSIConverter<std::shared_ptr<GPUOrigin2D>> {
-  static std::shared_ptr<GPUOrigin2D>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<GPUOrigin2D>();
-    if (!outOfBounds && arg.isObject()) {
-      if (arg.getObject(runtime).isArray(runtime)) {
-        auto array = arg.getObject(runtime).asArray(runtime);
-        auto size = array.size(runtime);
-        if (size == 0) {
-          throw std::runtime_error(
-              "Expected an array of size >1 for GPUTExtent2D");
-        }
-        if (size > 0) {
-          result->x = array.getValueAtIndex(runtime, 0).asNumber();
-        }
-        if (size > 1) {
-          result->y = array.getValueAtIndex(runtime, 1).asNumber();
-        }
-      } else {
-        auto object = arg.getObject(runtime);
-        if (object.hasProperty(runtime, "x")) {
-          result->x = object.getProperty(runtime, "x").asNumber();
-        }
-        if (object.hasProperty(runtime, "y")) {
-          result->y = object.getProperty(runtime, "y").asNumber();
-        }
-      }
-    } else {
-      throw std::runtime_error("Expected an object for GPUOrigin3D");
-    }
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<GPUOrigin2D> arg) {
-    // No conversions here
-    return jsi::Value::null();
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOrigin3D.h

@@ -1,62 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "JSIConverter.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-struct GPUOrigin3D {
-  double x = 0;
-  double y = 0;
-  double z = 0;
-};
-
-template <> struct JSIConverter<std::shared_ptr<GPUOrigin3D>> {
-  static std::shared_ptr<GPUOrigin3D>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<GPUOrigin3D>();
-    if (!outOfBounds && arg.isObject()) {
-      if (arg.getObject(runtime).isArray(runtime)) {
-        auto array = arg.getObject(runtime).asArray(runtime);
-        auto size = array.size(runtime);
-        if (size == 0) {
-          throw std::runtime_error(
-              "Expected an array of size >1 for GPUTExtent3D");
-        }
-        if (size > 0) {
-          result->x = array.getValueAtIndex(runtime, 0).asNumber();
-        }
-        if (size > 1) {
-          result->y = array.getValueAtIndex(runtime, 1).asNumber();
-        }
-        if (size > 2) {
-          result->z = array.getValueAtIndex(runtime, 2).asNumber();
-        }
-      } else {
-        auto object = arg.getObject(runtime);
-        if (object.hasProperty(runtime, "x")) {
-          result->x = object.getProperty(runtime, "x").asNumber();
-        }
-        if (object.hasProperty(runtime, "y")) {
-          result->y = object.getProperty(runtime, "y").asNumber();
-        }
-        if (object.hasProperty(runtime, "z")) {
-          result->z = object.getProperty(runtime, "z").asNumber();
-        }
-      }
-    } else {
-      throw std::runtime_error("Expected an object for GPUOrigin3D");
-    }
-    return result;
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<GPUOrigin3D> arg) {
-    // No conversions here
-    return jsi::Value::null();
-  }
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUOutOfMemoryError.h

@@ -1,33 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "NativeObject.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUOutOfMemoryError : public NativeObject<GPUOutOfMemoryError> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUOutOfMemoryError";
-
-  explicit GPUOutOfMemoryError(std::string message)
-      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-  std::string getMessage() { return _message; }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand",
-                  &GPUOutOfMemoryError::getBrand);
-    installGetter(runtime, prototype, "message",
-                  &GPUOutOfMemoryError::getMessage);
-  }
-
-private:
-  std::string _message;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUPipelineLayout.h

@@ -1,45 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUPipelineLayout : public NativeObject<GPUPipelineLayout> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUPipelineLayout";
-
-  explicit GPUPipelineLayout(wgpu::PipelineLayout instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUPipelineLayout::getBrand);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPUPipelineLayout::getLabel,
-                        &GPUPipelineLayout::setLabel);
-  }
-
-  inline const wgpu::PipelineLayout get() { return _instance; }
-
-private:
-  wgpu::PipelineLayout _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQuerySet.cpp

@@ -1,11 +0,0 @@
-#include "GPUQuerySet.h"
-
-namespace rnwgpu {
-
-void GPUQuerySet::destroy() { _instance.Destroy(); }
-
-wgpu::QueryType GPUQuerySet::getType() { return _instance.GetType(); }
-
-uint32_t GPUQuerySet::getCount() { return _instance.GetCount(); }
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQuerySet.h

@@ -1,73 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUQuerySet : public NativeObject<GPUQuerySet> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUQuerySet";
-
-  explicit GPUQuerySet(wgpu::QuerySet instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  void destroy();
-
-  wgpu::QueryType getType();
-  uint32_t getCount();
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUQuerySet::getBrand);
-    installMethod(runtime, prototype, "destroy", &GPUQuerySet::destroy);
-    installGetter(runtime, prototype, "type", &GPUQuerySet::getType);
-    installGetter(runtime, prototype, "count", &GPUQuerySet::getCount);
-    installGetterSetter(runtime, prototype, "label", &GPUQuerySet::getLabel,
-                        &GPUQuerySet::setLabel);
-  }
-
-  inline const wgpu::QuerySet get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    uint32_t count = getCount();
-    wgpu::QueryType type = getType();
-
-    // Estimate bytes per query based on type
-    size_t bytesPerQuery = 8; // Default estimate
-    switch (type) {
-    case wgpu::QueryType::Occlusion:
-      bytesPerQuery = 8; // 64-bit counter
-      break;
-    case wgpu::QueryType::Timestamp:
-      bytesPerQuery = 8; // 64-bit timestamp
-      break;
-    default:
-      bytesPerQuery = 8; // Safe default
-      break;
-    }
-
-    return static_cast<size_t>(count) * bytesPerQuery;
-  }
-
-private:
-  wgpu::QuerySet _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -1,169 +0,0 @@
-#include "GPUQueue.h"
-
-#include <limits>
-#include <memory>
-#include <vector>
-
-#include "Convertors.h"
-
-namespace rnwgpu {
-
-struct BufferSource {
-  void *data;
-  size_t size;            // in bytes
-  size_t bytesPerElement; // 1 for ArrayBuffers
-};
-
-void GPUQueue::submit(
-    std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers) {
-  std::vector<wgpu::CommandBuffer> bufs(commandBuffers.size());
-  for (size_t i = 0; i < commandBuffers.size(); i++) {
-    bufs[i] = commandBuffers[i]->get();
-  }
-  Convertor conv;
-  uint32_t bufs_size;
-  if (!conv(bufs_size, bufs.size())) {
-    return;
-  }
-  _instance.Submit(bufs_size, bufs.data());
-}
-
-void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
-                           uint64_t bufferOffset,
-                           std::shared_ptr<ArrayBuffer> data,
-                           std::optional<uint64_t> dataOffsetElements,
-                           std::optional<size_t> sizeElements) {
-  wgpu::Buffer buf = buffer->get();
-  BufferSource src{.data = data->_data,
-                   .size = data->_size,
-                   .bytesPerElement = data->_bytesPerElement};
-
-  // Note that in the JS semantics of WebGPU, writeBuffer works in number of
-  // elements of the typed arrays.
-  if (dataOffsetElements >
-      static_cast<uint64_t>(src.size / src.bytesPerElement)) {
-    throw std::runtime_error("dataOffset is larger than data's size.");
-    return;
-  }
-  uint64_t dataOffset = dataOffsetElements.value_or(0) * src.bytesPerElement;
-  src.data = reinterpret_cast<uint8_t *>(src.data) + dataOffset;
-  src.size -= dataOffset;
-
-  // Size defaults to dataSize - dataOffset. Instead of computing in elements,
-  // we directly use it in bytes, and convert the provided value, if any, in
-  // bytes.
-  uint64_t size64 = static_cast<uint64_t>(src.size);
-  if (sizeElements.has_value()) {
-    if (sizeElements.value() >
-        std::numeric_limits<uint64_t>::max() / src.bytesPerElement) {
-      throw std::runtime_error("size overflows.");
-      return;
-    }
-    size64 = sizeElements.value() * src.bytesPerElement;
-  }
-
-  if (size64 > static_cast<uint64_t>(src.size)) {
-    throw std::runtime_error("size + dataOffset is larger than data's size.");
-    return;
-  }
-
-  if (size64 % 4 != 0) {
-    throw std::runtime_error("size is not a multiple of 4 bytes.");
-
-    return;
-  }
-
-  assert(size64 <= std::numeric_limits<size_t>::max());
-  _instance.WriteBuffer(buf, bufferOffset, src.data,
-                        static_cast<size_t>(size64));
-}
-
-async::AsyncTaskHandle GPUQueue::onSubmittedWorkDone() {
-  auto queue = _instance;
-  return _async->postTask(
-      [queue](const async::AsyncTaskHandle::ResolveFunction &resolve,
-              const async::AsyncTaskHandle::RejectFunction &reject) {
-        queue.OnSubmittedWorkDone(
-            wgpu::CallbackMode::AllowProcessEvents,
-            [resolve, reject](wgpu::QueueWorkDoneStatus status,
-                              wgpu::StringView message) {
-              if (status == wgpu::QueueWorkDoneStatus::Success) {
-                resolve(nullptr);
-              } else {
-                std::string error =
-                    message.length ? std::string(message.data, message.length)
-                                   : "Queue work did not complete successfully";
-                reject(std::move(error));
-              }
-            });
-      });
-}
-
-void GPUQueue::copyExternalImageToTexture(
-    std::shared_ptr<GPUImageCopyExternalImage> source,
-    std::shared_ptr<GPUImageCopyTextureTagged> destination,
-    std::shared_ptr<GPUExtent3D> size) {
-  wgpu::TexelCopyTextureInfo dst{};
-  wgpu::TexelCopyBufferLayout layout{};
-  wgpu::Extent3D sz{};
-  Convertor conv;
-  uint32_t bytesPerPixel =
-      source->source->getSize() /
-      (source->source->getWidth() * source->source->getHeight());
-  auto dataLayout = std::make_shared<GPUImageDataLayout>(GPUImageDataLayout{
-      std::optional<double>{0.0},
-      std::optional<double>{
-          static_cast<double>(bytesPerPixel * source->source->getWidth())},
-      std::optional<double>{static_cast<double>(source->source->getHeight())}});
-  if (!conv(dst.aspect, destination->aspect) ||
-      !conv(dst.mipLevel, destination->mipLevel) ||
-      !conv(dst.origin, destination->origin) ||
-      !conv(dst.texture, destination->texture) ||
-      !conv(layout, dataLayout) || //
-      !conv(sz, size)) {
-    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
-  }
-
-  if (source->flipY.value_or(false)) {
-    // Calculate the row size and total size
-    uint32_t rowSize = bytesPerPixel * source->source->getWidth();
-    uint32_t totalSize = source->source->getSize();
-
-    // Create a new buffer for the flipped data
-    std::vector<uint8_t> flippedData(totalSize);
-
-    // Flip the data vertically
-    for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
-      std::memcpy(flippedData.data() +
-                      (source->source->getHeight() - 1 - row) * rowSize,
-                  static_cast<const uint8_t *>(source->source->getData()) +
-                      row * rowSize,
-                  rowSize);
-    }
-    // Use the flipped data for writing to texture
-    _instance.WriteTexture(&dst, flippedData.data(), totalSize, &layout, &sz);
-  } else {
-
-    _instance.WriteTexture(&dst, source->source->getData(),
-                           source->source->getSize(), &layout, &sz);
-  }
-}
-
-void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
-                            std::shared_ptr<ArrayBuffer> data,
-                            std::shared_ptr<GPUImageDataLayout> dataLayout,
-                            std::shared_ptr<GPUExtent3D> size) {
-  wgpu::TexelCopyTextureInfo dst{};
-  wgpu::TexelCopyBufferLayout layout{};
-  wgpu::Extent3D sz{};
-  Convertor conv;
-  if (!conv(dst, destination) ||   //
-      !conv(layout, dataLayout) || //
-      !conv(sz, size)) {
-    throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
-  }
-
-  _instance.WriteTexture(&dst, data->_data, data->_size, &layout, &sz);
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.h

@@ -1,81 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "rnwgpu/async/AsyncRunner.h"
-#include "rnwgpu/async/AsyncTaskHandle.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "ArrayBuffer.h"
-#include "GPUBuffer.h"
-#include "GPUCommandBuffer.h"
-#include "GPUImageCopyExternalImage.h"
-#include "GPUImageCopyTextureTagged.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUQueue : public NativeObject<GPUQueue> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUQueue";
-
-  explicit GPUQueue(wgpu::Queue instance,
-                    std::shared_ptr<async::AsyncRunner> async,
-                    std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _async(async),
-        _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  void submit(std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers);
-  async::AsyncTaskHandle onSubmittedWorkDone();
-  void writeBuffer(std::shared_ptr<GPUBuffer> buffer, uint64_t bufferOffset,
-                   std::shared_ptr<ArrayBuffer> data,
-                   std::optional<uint64_t> dataOffsetElements,
-                   std::optional<size_t> sizeElements);
-  void writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
-                    std::shared_ptr<ArrayBuffer> data,
-                    std::shared_ptr<GPUImageDataLayout> dataLayout,
-                    std::shared_ptr<GPUExtent3D> size);
-  void copyExternalImageToTexture(
-      std::shared_ptr<GPUImageCopyExternalImage> source,
-      std::shared_ptr<GPUImageCopyTextureTagged> destination,
-      std::shared_ptr<GPUExtent3D> copySize);
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPUQueue::getBrand);
-    installMethod(runtime, prototype, "submit", &GPUQueue::submit);
-    installMethod(runtime, prototype, "onSubmittedWorkDone",
-                  &GPUQueue::onSubmittedWorkDone);
-    installMethod(runtime, prototype, "writeBuffer", &GPUQueue::writeBuffer);
-    installMethod(runtime, prototype, "writeTexture", &GPUQueue::writeTexture);
-    installMethod(runtime, prototype, "copyExternalImageToTexture",
-                  &GPUQueue::copyExternalImageToTexture);
-    installGetterSetter(runtime, prototype, "label", &GPUQueue::getLabel,
-                        &GPUQueue::setLabel);
-  }
-
-  inline const wgpu::Queue get() { return _instance; }
-
-private:
-  wgpu::Queue _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderBundle.h

@@ -1,44 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPURenderBundle : public NativeObject<GPURenderBundle> {
-public:
-  static constexpr const char *CLASS_NAME = "GPURenderBundle";
-
-  explicit GPURenderBundle(wgpu::RenderBundle instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
-
-public:
-  std::string getBrand() { return CLASS_NAME; }
-
-  std::string getLabel() { return _label; }
-  void setLabel(const std::string &label) {
-    _label = label;
-    _instance.SetLabel(_label.c_str());
-  }
-
-  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installGetter(runtime, prototype, "__brand", &GPURenderBundle::getBrand);
-    installGetterSetter(runtime, prototype, "label", &GPURenderBundle::getLabel,
-                        &GPURenderBundle::setLabel);
-  }
-
-  inline const wgpu::RenderBundle get() { return _instance; }
-
-private:
-  wgpu::RenderBundle _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu