react-native-wgpu 0.1.0 → 0.1.3

package/cpp/rnwgpu/api/GPURenderPassEncoder.cpp

@@ -0,0 +1,161 @@
+#include "GPURenderPassEncoder.h"
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+void GPURenderPassEncoder::end() { _instance.End(); }
+
+void GPURenderPassEncoder::setPipeline(
+    std::shared_ptr<GPURenderPipeline> pipeline) {
+  _instance.SetPipeline(pipeline->get());
+}
+
+void GPURenderPassEncoder::draw(uint32_t vertexCount,
+                                std::optional<uint32_t> instanceCount,
+                                std::optional<uint32_t> firstVertex,
+                                std::optional<uint32_t> firstInstance) {
+  _instance.Draw(vertexCount, instanceCount.value_or(1),
+                 firstVertex.value_or(0), firstInstance.value_or(0));
+}
+void GPURenderPassEncoder::setVertexBuffer(
+    uint32_t slot,
+    std::variant<std::nullptr_t, 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.SetVertexBuffer(slot, b, offset.value_or(0), s);
+}
+
+void GPURenderPassEncoder::setBindGroup(
+    uint32_t groupIndex,
+    std::variant<std::nullptr_t, std::shared_ptr<GPUBindGroup>> bindGroup,
+    std::optional<std::vector<uint32_t>> dynamicOffsets) {
+  auto dynOffsets = dynamicOffsets.value_or(std::vector<uint32_t>());
+  if (dynOffsets.size() == 0) {
+    if (std::holds_alternative<nullptr_t>(bindGroup)) {
+      _instance.SetBindGroup(groupIndex, nullptr, 0, nullptr);
+    } else {
+      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
+      _instance.SetBindGroup(groupIndex, group->get(), 0, nullptr);
+    }
+  } else {
+    if (std::holds_alternative<nullptr_t>(bindGroup)) {
+      _instance.SetBindGroup(groupIndex, nullptr, dynOffsets.size(),
+                             dynamicOffsets->data());
+    } else {
+      auto group = std::get<std::shared_ptr<GPUBindGroup>>(bindGroup);
+      _instance.SetBindGroup(groupIndex, group->get(), dynOffsets.size(),
+                             dynamicOffsets->data());
+    }
+  }
+}
+
+void GPURenderPassEncoder::setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
+                                          wgpu::IndexFormat indexFormat,
+                                          std::optional<uint64_t> offset,
+                                          std::optional<uint64_t> size) {
+  Convertor conv;
+
+  wgpu::Buffer b{};
+  wgpu::IndexFormat f{};
+  uint64_t o = 0;
+  uint64_t s = wgpu::kWholeSize;
+  if (!conv(b, buffer) ||      //
+      !conv(f, indexFormat) || //
+      !conv(o, offset) ||      //
+      !conv(s, size)) {
+    return;
+  }
+
+  _instance.SetIndexBuffer(b, f, o, s);
+}
+
+void GPURenderPassEncoder::endOcclusionQuery() {
+  _instance.EndOcclusionQuery();
+}
+
+void GPURenderPassEncoder::beginOcclusionQuery(uint32_t queryIndex) {
+  _instance.BeginOcclusionQuery(queryIndex);
+}
+
+void GPURenderPassEncoder::drawIndexed(uint32_t indexCount,
+                                       std::optional<uint32_t> instanceCount,
+                                       std::optional<uint32_t> firstIndex,
+                                       std::optional<double> baseVertex,
+                                       std::optional<uint32_t> firstInstance) {
+  _instance.DrawIndexed(indexCount, instanceCount.value_or(1),
+                        firstIndex.value_or(0), baseVertex.value_or(0),
+                        firstInstance.value_or(0));
+}
+
+void GPURenderPassEncoder::executeBundles(
+    std::vector<std::shared_ptr<GPURenderBundle>> bundles_in) {
+  Convertor conv;
+
+  wgpu::RenderBundle *bundles = nullptr;
+  size_t bundleCount = 0;
+  if (!conv(bundles, bundleCount, bundles_in)) {
+    return;
+  }
+
+  _instance.ExecuteBundles(bundleCount, bundles);
+}
+
+void GPURenderPassEncoder::setScissorRect(uint32_t x, uint32_t y,
+                                          uint32_t width, uint32_t height) {
+  _instance.SetScissorRect(x, y, width, height);
+}
+
+void GPURenderPassEncoder::setViewport(double x, double y, double width,
+                                       double height, double minDepth,
+                                       double maxDepth) {
+  _instance.SetViewport(x, y, width, height, minDepth, maxDepth);
+}
+
+void GPURenderPassEncoder::setBlendConstant(std::shared_ptr<GPUColor> color) {
+  Convertor conv;
+  wgpu::Color c{};
+  if (!conv(c, color)) {
+    return;
+  }
+  _instance.SetBlendConstant(&c);
+}
+
+void GPURenderPassEncoder::setStencilReference(uint32_t reference) {
+  _instance.SetStencilReference(reference);
+}
+
+void GPURenderPassEncoder::pushDebugGroup(std::string groupLabel) {
+  _instance.PushDebugGroup(groupLabel.c_str());
+}
+
+void GPURenderPassEncoder::popDebugGroup() { _instance.PopDebugGroup(); }
+
+void GPURenderPassEncoder::insertDebugMarker(std::string markerLabel) {
+  _instance.InsertDebugMarker(markerLabel.c_str());
+}
+void GPURenderPassEncoder::drawIndirect(
+    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
+  Convertor conv;
+  wgpu::Buffer b{};
+  if (!conv(b, indirectBuffer)) {
+    return;
+  }
+  _instance.DrawIndirect(b, indirectOffset);
+}
+void GPURenderPassEncoder::drawIndexedIndirect(
+    std::shared_ptr<GPUBuffer> indirectBuffer, uint64_t indirectOffset) {
+  Convertor conv;
+  wgpu::Buffer b{};
+  if (!conv(b, indirectBuffer)) {
+    return;
+  }
+  _instance.DrawIndexedIndirect(b, indirectOffset);
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPassEncoder.h

@@ -1,16 +1,25 @@
 #pragma once
 
-#include <future>
 #include <memory>
+#include <optional>
 #include <string>
+#include <variant>
+#include <vector>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUBindGroup.h"
+#include "GPUBuffer.h"
+#include "GPUColor.h"
+#include "GPURenderBundle.h"
+#include "GPURenderPipeline.h"
+
 namespace rnwgpu {
 
 namespace m = margelo;
@@ -25,16 +34,97 @@ public:
 public:
   std::string getBrand() { return _name; }
 
+  void setViewport(double x, double y, double width, double height,
+                   double minDepth, double maxDepth);
+  void setScissorRect(uint32_t x, uint32_t y, uint32_t width, uint32_t height);
+  void setBlendConstant(std::shared_ptr<GPUColor> color);
+  void setStencilReference(uint32_t reference);
+  void beginOcclusionQuery(uint32_t queryIndex);
+  void endOcclusionQuery();
+  void executeBundles(std::vector<std::shared_ptr<GPURenderBundle>> bundles);
+  void end();
+  void pushDebugGroup(std::string groupLabel);
+  void popDebugGroup();
+  void insertDebugMarker(std::string markerLabel);
+  void setBindGroup(
+      uint32_t index,
+      std::variant<std::nullptr_t, std::shared_ptr<GPUBindGroup>> bindGroup,
+      std::optional<std::vector<uint32_t>> dynamicOffsets);
+  void setPipeline(std::shared_ptr<GPURenderPipeline> pipeline);
+  void setIndexBuffer(std::shared_ptr<GPUBuffer> buffer,
+                      wgpu::IndexFormat indexFormat,
+                      std::optional<uint64_t> offset,
+                      std::optional<uint64_t> size);
+  void setVertexBuffer(
+      uint32_t slot,
+      std::variant<std::nullptr_t, std::shared_ptr<GPUBuffer>> buffer,
+      std::optional<uint64_t> offset, std::optional<uint64_t> size);
+  void draw(uint32_t vertexCount, std::optional<uint32_t> instanceCount,
+            std::optional<uint32_t> firstVertex,
+            std::optional<uint32_t> firstInstance);
+  void drawIndexed(uint32_t indexCount, std::optional<uint32_t> instanceCount,
+                   std::optional<uint32_t> firstIndex,
+                   std::optional<double> baseVertex,
+                   std::optional<uint32_t> firstInstance);
+  void drawIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
+                    uint64_t indirectOffset);
+  void drawIndexedIndirect(std::shared_ptr<GPUBuffer> indirectBuffer,
+                           uint64_t indirectOffset);
+
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPURenderPassEncoder::getBrand, this);
+    registerHybridMethod("setViewport", &GPURenderPassEncoder::setViewport,
+                         this);
+    registerHybridMethod("setScissorRect",
+                         &GPURenderPassEncoder::setScissorRect, this);
+    registerHybridMethod("setBlendConstant",
+                         &GPURenderPassEncoder::setBlendConstant, this);
+    registerHybridMethod("setStencilReference",
+                         &GPURenderPassEncoder::setStencilReference, this);
+    registerHybridMethod("beginOcclusionQuery",
+                         &GPURenderPassEncoder::beginOcclusionQuery, this);
+    registerHybridMethod("endOcclusionQuery",
+                         &GPURenderPassEncoder::endOcclusionQuery, this);
+    registerHybridMethod("executeBundles",
+                         &GPURenderPassEncoder::executeBundles, this);
+    registerHybridMethod("end", &GPURenderPassEncoder::end, this);
+    registerHybridMethod("pushDebugGroup",
+                         &GPURenderPassEncoder::pushDebugGroup, this);
+    registerHybridMethod("popDebugGroup", &GPURenderPassEncoder::popDebugGroup,
+                         this);
+    registerHybridMethod("insertDebugMarker",
+                         &GPURenderPassEncoder::insertDebugMarker, this);
+    registerHybridMethod("setBindGroup", &GPURenderPassEncoder::setBindGroup,
+                         this);
+    registerHybridMethod("setPipeline", &GPURenderPassEncoder::setPipeline,
+                         this);
+    registerHybridMethod("setIndexBuffer",
+                         &GPURenderPassEncoder::setIndexBuffer, this);
+    registerHybridMethod("setVertexBuffer",
+                         &GPURenderPassEncoder::setVertexBuffer, this);
+    registerHybridMethod("draw", &GPURenderPassEncoder::draw, this);
+    registerHybridMethod("drawIndexed", &GPURenderPassEncoder::drawIndexed,
+                         this);
+    registerHybridMethod("drawIndirect", &GPURenderPassEncoder::drawIndirect,
+                         this);
+    registerHybridMethod("drawIndexedIndirect",
+                         &GPURenderPassEncoder::drawIndexedIndirect, this);
 
     registerHybridGetter("label", &GPURenderPassEncoder::getLabel, this);
+    registerHybridSetter("label", &GPURenderPassEncoder::setLabel, this);
   }
 
+  inline const wgpu::RenderPassEncoder get() { return _instance; }
+
 private:
   wgpu::RenderPassEncoder _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPipeline.cpp

@@ -0,0 +1,13 @@
+#include "GPURenderPipeline.h"
+
+#include <memory>
+
+namespace rnwgpu {
+
+std::shared_ptr<GPUBindGroupLayout>
+GPURenderPipeline::getBindGroupLayout(uint32_t groupIndex) {
+  auto bindGroupLayout = _instance.GetBindGroupLayout(groupIndex);
+  return std::make_shared<GPUBindGroupLayout>(bindGroupLayout, "");
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPipeline.h

@@ -1,16 +1,18 @@
 #pragma once
 
-#include <future>
 #include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUBindGroupLayout.h"
+
 namespace rnwgpu {
 
 namespace m = margelo;
@@ -23,16 +25,29 @@ public:
 public:
   std::string getBrand() { return _name; }
 
+  std::shared_ptr<GPUBindGroupLayout> getBindGroupLayout(uint32_t index);
+
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPURenderPipeline::getBrand, this);
+    registerHybridMethod("getBindGroupLayout",
+                         &GPURenderPipeline::getBindGroupLayout, this);
 
     registerHybridGetter("label", &GPURenderPipeline::getLabel, this);
+    registerHybridSetter("label", &GPURenderPipeline::setLabel, this);
   }
 
+  inline const wgpu::RenderPipeline get() { return _instance; }
+
 private:
   wgpu::RenderPipeline _instance;
   std::string _label;
+  friend class GPUDevice;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSampler.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -24,15 +23,23 @@ public:
   std::string getBrand() { return _name; }
 
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUSampler::getBrand, this);
 
     registerHybridGetter("label", &GPUSampler::getLabel, this);
+    registerHybridSetter("label", &GPUSampler::setLabel, this);
   }
 
+  inline const wgpu::Sampler get() { return _instance; }
+
 private:
   wgpu::Sampler _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -0,0 +1,39 @@
+#include "GPUShaderModule.h"
+
+#include <utility>
+
+namespace rnwgpu {
+
+std::future<std::shared_ptr<GPUCompilationInfo>>
+GPUShaderModule::getCompilationInfo() {
+  return _async->runAsync([=](wgpu::Instance *instance) {
+    wgpu::CompilationInfo compilationInfo;
+    auto result = std::make_shared<GPUCompilationInfo>();
+    auto future = _instance.GetCompilationInfo(
+        wgpu::CallbackMode::WaitAnyOnly,
+        [&result](wgpu::CompilationInfoRequestStatus status,
+                  wgpu::CompilationInfo const *compilationInfo) {
+          if (status == wgpu::CompilationInfoRequestStatus::Success &&
+              compilationInfo) {
+            for (size_t i = 0; i < compilationInfo->messageCount; ++i) {
+              const auto &wgpuMessage = compilationInfo->messages[i];
+              GPUCompilationMessage message;
+              message.message = wgpuMessage.message ? wgpuMessage.message : "";
+              message.type = wgpuMessage.type;
+              message.lineNum = wgpuMessage.lineNum;
+              message.linePos = wgpuMessage.linePos;
+              message.offset = wgpuMessage.offset;
+              message.length = wgpuMessage.length;
+              message.utf16LinePos = wgpuMessage.utf16LinePos;
+              message.utf16Offset = wgpuMessage.utf16Offset;
+              message.utf16Length = wgpuMessage.utf16Length;
+              result->_messages.push_back(std::move(message));
+            }
+          }
+        });
+    instance->WaitAny(future, UINT64_MAX);
+    return result;
+  });
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -5,34 +5,53 @@
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUCompilationInfo.h"
+
 namespace rnwgpu {
 
 namespace m = margelo;
 
 class GPUShaderModule : public m::HybridObject {
 public:
-  explicit GPUShaderModule(wgpu::ShaderModule instance, std::string label)
-      : HybridObject("GPUShaderModule"), _instance(instance), _label(label) {}
+  explicit GPUShaderModule(wgpu::ShaderModule instance,
+                           std::shared_ptr<AsyncRunner> async,
+                           std::string label)
+      : HybridObject("GPUShaderModule"), _instance(instance), _async(async),
+        _label(label) {}
 
 public:
   std::string getBrand() { return _name; }
 
+  std::future<std::shared_ptr<GPUCompilationInfo>> getCompilationInfo();
+
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUShaderModule::getBrand, this);
+    registerHybridMethod("getCompilationInfo",
+                         &GPUShaderModule::getCompilationInfo, this);
 
     registerHybridGetter("label", &GPUShaderModule::getLabel, this);
+    registerHybridSetter("label", &GPUShaderModule::setLabel, this);
   }
 
+  inline const wgpu::ShaderModule get() { return _instance; }
+
 private:
   wgpu::ShaderModule _instance;
+  std::shared_ptr<AsyncRunner> _async;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSupportedLimits.cpp

@@ -0,0 +1,133 @@
+#include "GPUSupportedLimits.h"
+
+namespace rnwgpu {
+
+double GPUSupportedLimits::getMaxTextureDimension1D() {
+  return _instance.limits.maxTextureDimension1D;
+}
+
+double GPUSupportedLimits::getMaxTextureDimension2D() {
+  return _instance.limits.maxTextureDimension2D;
+}
+
+double GPUSupportedLimits::getMaxTextureDimension3D() {
+  return _instance.limits.maxTextureDimension3D;
+}
+
+double GPUSupportedLimits::getMaxTextureArrayLayers() {
+  return _instance.limits.maxTextureArrayLayers;
+}
+
+double GPUSupportedLimits::getMaxBindGroups() {
+  return _instance.limits.maxBindGroups;
+}
+
+double GPUSupportedLimits::getMaxBindGroupsPlusVertexBuffers() {
+  return _instance.limits.maxBindGroupsPlusVertexBuffers;
+}
+
+double GPUSupportedLimits::getMaxBindingsPerBindGroup() {
+  return _instance.limits.maxBindingsPerBindGroup;
+}
+
+double GPUSupportedLimits::getMaxDynamicUniformBuffersPerPipelineLayout() {
+  return _instance.limits.maxDynamicUniformBuffersPerPipelineLayout;
+}
+
+double GPUSupportedLimits::getMaxDynamicStorageBuffersPerPipelineLayout() {
+  return _instance.limits.maxDynamicStorageBuffersPerPipelineLayout;
+}
+
+double GPUSupportedLimits::getMaxSampledTexturesPerShaderStage() {
+  return _instance.limits.maxSampledTexturesPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxSamplersPerShaderStage() {
+  return _instance.limits.maxSamplersPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxStorageBuffersPerShaderStage() {
+  return _instance.limits.maxStorageBuffersPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxStorageTexturesPerShaderStage() {
+  return _instance.limits.maxStorageTexturesPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxUniformBuffersPerShaderStage() {
+  return _instance.limits.maxUniformBuffersPerShaderStage;
+}
+
+double GPUSupportedLimits::getMaxUniformBufferBindingSize() {
+  return _instance.limits.maxUniformBufferBindingSize;
+}
+
+double GPUSupportedLimits::getMaxStorageBufferBindingSize() {
+  return _instance.limits.maxStorageBufferBindingSize;
+}
+
+double GPUSupportedLimits::getMinUniformBufferOffsetAlignment() {
+  return _instance.limits.minUniformBufferOffsetAlignment;
+}
+
+double GPUSupportedLimits::getMinStorageBufferOffsetAlignment() {
+  return _instance.limits.minStorageBufferOffsetAlignment;
+}
+
+double GPUSupportedLimits::getMaxVertexBuffers() {
+  return _instance.limits.maxVertexBuffers;
+}
+
+double GPUSupportedLimits::getMaxBufferSize() {
+  return _instance.limits.maxBufferSize;
+}
+
+double GPUSupportedLimits::getMaxVertexAttributes() {
+  return _instance.limits.maxVertexAttributes;
+}
+
+double GPUSupportedLimits::getMaxVertexBufferArrayStride() {
+  return _instance.limits.maxVertexBufferArrayStride;
+}
+
+double GPUSupportedLimits::getMaxInterStageShaderComponents() {
+  return _instance.limits.maxInterStageShaderComponents;
+}
+
+double GPUSupportedLimits::getMaxInterStageShaderVariables() {
+  return _instance.limits.maxInterStageShaderVariables;
+}
+
+double GPUSupportedLimits::getMaxColorAttachments() {
+  return _instance.limits.maxColorAttachments;
+}
+
+double GPUSupportedLimits::getMaxColorAttachmentBytesPerSample() {
+  return _instance.limits.maxColorAttachmentBytesPerSample;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupStorageSize() {
+  return _instance.limits.maxComputeWorkgroupStorageSize;
+}
+
+double GPUSupportedLimits::getMaxComputeInvocationsPerWorkgroup() {
+  return _instance.limits.maxComputeInvocationsPerWorkgroup;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupSizeX() {
+  return _instance.limits.maxComputeWorkgroupSizeX;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupSizeY() {
+  return _instance.limits.maxComputeWorkgroupSizeY;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupSizeZ() {
+  return _instance.limits.maxComputeWorkgroupSizeZ;
+}
+
+double GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension() {
+  return _instance.limits.maxComputeWorkgroupsPerDimension;
+}
+
+} // namespace rnwgpu