react-native-wgpu 0.5.13 → 0.5.14

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

@@ -1,52 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "Unions.h"
-
-#include "NativeObject.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUBindGroupLayout : public NativeObject<GPUBindGroupLayout> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUBindGroupLayout";
-
-  explicit GPUBindGroupLayout(wgpu::BindGroupLayout 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", &GPUBindGroupLayout::getBrand);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPUBindGroupLayout::getLabel,
-                        &GPUBindGroupLayout::setLabel);
-  }
-
-  inline const wgpu::BindGroupLayout get() { return _instance; }
-
-  size_t getMemoryPressure() override {
-    // Bind group layouts define the structure/schema for bind groups
-    // They store binding descriptors, types, and validation info
-    // Estimate: 512 bytes per layout (smaller than actual bind groups)
-    return 512;
-  }
-
-private:
-  wgpu::BindGroupLayout _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -1,97 +0,0 @@
-#include "GPUBuffer.h"
-
-#include <memory>
-#include <utility>
-
-#include "Convertors.h"
-
-namespace rnwgpu {
-
-std::shared_ptr<ArrayBuffer>
-GPUBuffer::getMappedRange(std::optional<size_t> o, std::optional<size_t> size) {
-  auto offset = o.value_or(0);
-  uint64_t s = size.has_value() ? size.value() : (_instance.GetSize() - offset);
-
-  uint64_t start = offset;
-  uint64_t end = offset + s;
-  // for (auto& mapping : mappings_) {
-  //     if (mapping.Intersects(start, end)) {
-  //         Errors::OperationError(env).ThrowAsJavaScriptException();
-  //         return {};
-  //     }
-  // }
-
-  auto *ptr =
-      (_instance.GetUsage() & wgpu::BufferUsage::MapWrite)
-          ? _instance.GetMappedRange(offset, s)
-          : const_cast<void *>(_instance.GetConstMappedRange(offset, s));
-  if (!ptr) {
-    throw std::runtime_error("Failed to get getMappedRange");
-  }
-  auto array_buffer = std::make_shared<ArrayBuffer>(ptr, s, 1);
-  // TODO(crbug.com/dawn/1135): Ownership here is the wrong way around.
-  // mappings_.emplace_back(Mapping{start, end,
-  // Napi::Persistent(array_buffer)});
-  return array_buffer;
-}
-
-void GPUBuffer::destroy() { _instance.Destroy(); }
-
-async::AsyncTaskHandle GPUBuffer::mapAsync(uint64_t modeIn,
-                                           std::optional<uint64_t> offset,
-                                           std::optional<uint64_t> size) {
-  Convertor conv;
-  wgpu::MapMode mode;
-  if (!conv(mode, modeIn)) {
-    throw std::runtime_error("Couldn't get MapMode");
-  }
-  uint64_t rangeSize = size.has_value()
-                           ? size.value()
-                           : (_instance.GetSize() - offset.value_or(0));
-  auto bufferHandle = _instance;
-  uint64_t resolvedOffset = offset.value_or(0);
-
-  return _async->postTask(
-      [bufferHandle, mode, resolvedOffset,
-       rangeSize](const async::AsyncTaskHandle::ResolveFunction &resolve,
-                  const async::AsyncTaskHandle::RejectFunction &reject) {
-        bufferHandle.MapAsync(mode, resolvedOffset, rangeSize,
-                              wgpu::CallbackMode::AllowProcessEvents,
-                              [resolve, reject](wgpu::MapAsyncStatus status,
-                                                wgpu::StringView message) {
-                                switch (status) {
-                                case wgpu::MapAsyncStatus::Success:
-                                  resolve(nullptr);
-                                  break;
-                                case wgpu::MapAsyncStatus::CallbackCancelled:
-                                  reject("MapAsyncStatus::CallbackCancelled");
-                                  break;
-                                case wgpu::MapAsyncStatus::Error:
-                                  reject("MapAsyncStatus::Error");
-                                  break;
-                                case wgpu::MapAsyncStatus::Aborted:
-                                  reject("MapAsyncStatus::Aborted");
-                                  break;
-                                default:
-                                  reject(
-                                      "MapAsyncStatus: " +
-                                      std::to_string(static_cast<int>(status)));
-                                  break;
-                                }
-                              });
-      });
-}
-
-void GPUBuffer::unmap() { _instance.Unmap(); }
-
-uint64_t GPUBuffer::getSize() { return _instance.GetSize(); }
-
-double GPUBuffer::getUsage() {
-  return static_cast<double>(_instance.GetUsage());
-}
-
-wgpu::BufferMapState GPUBuffer::getMapState() {
-  return _instance.GetMapState();
-}
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -1,87 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <optional>
-#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"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class GPUBuffer : public NativeObject<GPUBuffer> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUBuffer";
-
-  explicit GPUBuffer(wgpu::Buffer 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; }
-
-  async::AsyncTaskHandle mapAsync(uint64_t modeIn,
-                                  std::optional<uint64_t> offset,
-                                  std::optional<uint64_t> size);
-  std::shared_ptr<ArrayBuffer> getMappedRange(std::optional<size_t> offset,
-                                              std::optional<size_t> size);
-  void unmap();
-  void destroy();
-
-  uint64_t getSize();
-  double getUsage();
-  wgpu::BufferMapState getMapState();
-
-  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", &GPUBuffer::getBrand);
-    installMethod(runtime, prototype, "mapAsync", &GPUBuffer::mapAsync);
-    installMethod(runtime, prototype, "getMappedRange",
-                  &GPUBuffer::getMappedRange);
-    installMethod(runtime, prototype, "unmap", &GPUBuffer::unmap);
-    installMethod(runtime, prototype, "destroy", &GPUBuffer::destroy);
-    installGetter(runtime, prototype, "size", &GPUBuffer::getSize);
-    installGetter(runtime, prototype, "usage", &GPUBuffer::getUsage);
-    installGetter(runtime, prototype, "mapState", &GPUBuffer::getMapState);
-    installGetterSetter(runtime, prototype, "label", &GPUBuffer::getLabel,
-                        &GPUBuffer::setLabel);
-  }
-
-  inline const wgpu::Buffer get() { return _instance; }
-
-  size_t getMemoryPressure() override { return static_cast<size_t>(getSize()); }
-
-private:
-  wgpu::Buffer _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
-  std::string _label;
-  struct Mapping {
-    uint64_t start;
-    uint64_t end;
-    inline bool Intersects(uint64_t s, uint64_t e) const {
-      return s < end && e > start;
-    }
-    std::shared_ptr<ArrayBuffer> buffer;
-  };
-  std::vector<Mapping> mappings;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -1,67 +0,0 @@
-#include "GPUCanvasContext.h"
-#include "Convertors.h"
-#include "RNWebGPUManager.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();
-  // Pass reportsMemoryPressure=false to avoid triggering spurious Hermes GC
-  // cycles every frame since the canvas texture doesn't own the buffer.
-  return std::make_shared<GPUTexture>(texture, "", false);
-}
-
-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

@@ -1,66 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <utility>
-
-#include "Unions.h"
-
-#include "webgpu/webgpu_cpp.h"
-
-#include "NativeObject.h"
-
-#include "Canvas.h"
-#include "GPU.h"
-#include "GPUCanvasConfiguration.h"
-#include "GPUTexture.h"
-#include "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);
-  }
-
-  // TODO: is this ok?
-  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/GPUCommandBuffer.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 GPUCommandBuffer : public NativeObject<GPUCommandBuffer> {
-public:
-  static constexpr const char *CLASS_NAME = "GPUCommandBuffer";
-
-  explicit GPUCommandBuffer(wgpu::CommandBuffer 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", &GPUCommandBuffer::getBrand);
-    installGetterSetter(runtime, prototype, "label",
-                        &GPUCommandBuffer::getLabel,
-                        &GPUCommandBuffer::setLabel);
-  }
-
-  inline const wgpu::CommandBuffer get() { return _instance; }
-
-private:
-  wgpu::CommandBuffer _instance;
-  std::string _label;
-};
-
-} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCommandEncoder.cpp

@@ -1,179 +0,0 @@
-#include "GPUCommandEncoder.h"
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "Convertors.h"
-
-namespace rnwgpu {
-
-void GPUCommandEncoder::copyBufferToBuffer(
-    std::shared_ptr<GPUBuffer> source, uint64_t sourceOffset,
-    std::shared_ptr<GPUBuffer> destination, uint64_t destinationOffset,
-    uint64_t size) {
-  Convertor conv;
-
-  wgpu::Buffer src{};
-  wgpu::Buffer dst{};
-  if (!conv(src, source) || //
-      !conv(dst, destination)) {
-    return;
-  }
-  _instance.CopyBufferToBuffer(src, sourceOffset, dst, destinationOffset, size);
-}
-
-std::shared_ptr<GPUCommandBuffer> GPUCommandEncoder::finish(
-    std::optional<std::shared_ptr<GPUCommandBufferDescriptor>> descriptor) {
-  wgpu::CommandBufferDescriptor desc{};
-  Convertor conv;
-  if (!conv(desc, descriptor)) {
-    throw std::runtime_error(
-        "GPUCommandEncoder::finish(): error with GPUCommandBufferDescriptor");
-  }
-  auto commandBuffer = _instance.Finish(&desc);
-  return std::make_shared<GPUCommandBuffer>(
-      commandBuffer,
-      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
-}
-
-std::shared_ptr<GPURenderPassEncoder> GPUCommandEncoder::beginRenderPass(
-    std::shared_ptr<GPURenderPassDescriptor> descriptor) {
-
-  wgpu::RenderPassDescriptor desc{};
-  wgpu::RenderPassMaxDrawCount maxDrawCountDesc{};
-  desc.nextInChain = &maxDrawCountDesc;
-  Convertor conv;
-
-  // TODO: why is this not in Converter
-  if (!conv(desc.colorAttachments, desc.colorAttachmentCount,
-            descriptor->colorAttachments) ||
-      !conv(desc.depthStencilAttachment, descriptor->depthStencilAttachment) ||
-      !conv(desc.label, descriptor->label) ||
-      !conv(desc.occlusionQuerySet, descriptor->occlusionQuerySet) ||
-      !conv(desc.timestampWrites, descriptor->timestampWrites) ||
-      !conv(maxDrawCountDesc.maxDrawCount, descriptor->maxDrawCount)) {
-    throw std::runtime_error("PUCommandEncoder::beginRenderPass(): couldn't "
-                             "get GPURenderPassDescriptor");
-  }
-  auto renderPass = _instance.BeginRenderPass(&desc);
-  return std::make_shared<GPURenderPassEncoder>(renderPass,
-                                                descriptor->label.value_or(""));
-}
-
-void GPUCommandEncoder::copyTextureToBuffer(
-    std::shared_ptr<GPUImageCopyTexture> source,
-    std::shared_ptr<GPUImageCopyBuffer> destination,
-    std::shared_ptr<GPUExtent3D> copySize) {
-  Convertor conv;
-  wgpu::TexelCopyTextureInfo src{};
-  wgpu::TexelCopyBufferInfo dst{};
-  wgpu::Extent3D size{};
-  if (!conv(src, source) ||      //
-      !conv(dst, destination) || //
-      !conv(size, copySize)) {
-    return;
-  }
-  _instance.CopyTextureToBuffer(&src, &dst, &size);
-}
-
-void GPUCommandEncoder::copyTextureToTexture(
-    std::shared_ptr<GPUImageCopyTexture> source,
-    std::shared_ptr<GPUImageCopyTexture> destination,
-    std::shared_ptr<GPUExtent3D> copySize) {
-  Convertor conv;
-
-  wgpu::TexelCopyTextureInfo src{};
-  wgpu::TexelCopyTextureInfo dst{};
-  wgpu::Extent3D size{};
-  if (!conv(src, source) ||      //
-      !conv(dst, destination) || //
-      !conv(size, copySize)) {
-    return;
-  }
-
-  _instance.CopyTextureToTexture(&src, &dst, &size);
-}
-
-std::shared_ptr<GPUComputePassEncoder> GPUCommandEncoder::beginComputePass(
-    std::optional<std::shared_ptr<GPUComputePassDescriptor>> descriptor) {
-  wgpu::ComputePassDescriptor desc;
-  Convertor conv;
-  if (!conv(desc, descriptor)) {
-    throw std::runtime_error("GPUCommandEncoder.beginComputePass(): couldn't "
-                             "access GPUComputePassDescriptor.");
-  }
-  auto computePass = _instance.BeginComputePass(&desc);
-  return std::make_shared<GPUComputePassEncoder>(
-      computePass,
-      descriptor.has_value() ? descriptor.value()->label.value_or("") : "");
-}
-
-void GPUCommandEncoder::resolveQuerySet(std::shared_ptr<GPUQuerySet> querySet,
-                                        uint32_t firstQuery,
-                                        uint32_t queryCount,
-                                        std::shared_ptr<GPUBuffer> destination,
-                                        uint64_t destinationOffset) {
-  Convertor conv;
-
-  wgpu::QuerySet q{};
-  uint32_t f = 0;
-  uint32_t c = 0;
-  wgpu::Buffer b{};
-  uint64_t o = 0;
-
-  if (!conv(q, querySet) ||    //
-      !conv(f, firstQuery) ||  //
-      !conv(c, queryCount) ||  //
-      !conv(b, destination) || //
-      !conv(o, destinationOffset)) {
-    return;
-  }
-
-  _instance.ResolveQuerySet(q, f, c, b, o);
-}
-
-void GPUCommandEncoder::copyBufferToTexture(
-    std::shared_ptr<GPUImageCopyBuffer> source,
-    std::shared_ptr<GPUImageCopyTexture> destination,
-    std::shared_ptr<GPUExtent3D> copySize) {
-  Convertor conv;
-
-  wgpu::TexelCopyBufferInfo src{};
-  wgpu::TexelCopyTextureInfo dst{};
-  wgpu::Extent3D size{};
-  if (!conv(src, source) ||      //
-      !conv(dst, destination) || //
-      !conv(size, copySize)) {
-    return;
-  }
-
-  _instance.CopyBufferToTexture(&src, &dst, &size);
-}
-
-void GPUCommandEncoder::clearBuffer(std::shared_ptr<GPUBuffer> buffer,
-                                    std::optional<uint64_t> offset,
-                                    std::optional<uint64_t> size) {
-  Convertor conv;
-
-  wgpu::Buffer b{};
-  uint64_t s = wgpu::kWholeSize;
-  if (!conv(b, buffer) || //
-      !conv(s, size)) {
-    return;
-  }
-
-  _instance.ClearBuffer(b, offset.value_or(0), s);
-}
-
-void GPUCommandEncoder::pushDebugGroup(std::string groupLabel) {
-  _instance.PushDebugGroup(groupLabel.c_str());
-}
-
-void GPUCommandEncoder::popDebugGroup() { _instance.PopDebugGroup(); }
-
-void GPUCommandEncoder::insertDebugMarker(std::string markerLabel) {
-  _instance.InsertDebugMarker(markerLabel.c_str());
-}
-
-} // namespace rnwgpu