react-native-wgpu 0.1.0 → 0.1.3

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -2,43 +2,79 @@
 
 #include <future>
 #include <memory>
+#include <optional>
 #include <string>
+#include <vector>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "ArrayBuffer.h"
+
 namespace rnwgpu {
 
 namespace m = margelo;
 
 class GPUBuffer : public m::HybridObject {
 public:
-  explicit GPUBuffer(wgpu::Buffer instance, std::string label)
-      : HybridObject("GPUBuffer"), _instance(instance), _label(label) {}
+  explicit GPUBuffer(wgpu::Buffer instance, std::shared_ptr<AsyncRunner> async,
+                     std::string label)
+      : HybridObject("GPUBuffer"), _instance(instance), _async(async),
+        _label(label) {}
 
 public:
   std::string getBrand() { return _name; }
 
-  std::shared_ptr<MutableJSIBuffer> getMappedRange(std::optional<size_t> offset,
-                                                   std::optional<size_t> size);
+  std::future<void> 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());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUBuffer::getBrand, this);
+    registerHybridMethod("mapAsync", &GPUBuffer::mapAsync, this);
     registerHybridMethod("getMappedRange", &GPUBuffer::getMappedRange, this);
     registerHybridMethod("unmap", &GPUBuffer::unmap, this);
-
+    registerHybridMethod("destroy", &GPUBuffer::destroy, this);
+    registerHybridGetter("size", &GPUBuffer::getSize, this);
+    registerHybridGetter("usage", &GPUBuffer::getUsage, this);
+    registerHybridGetter("mapState", &GPUBuffer::getMapState, this);
     registerHybridGetter("label", &GPUBuffer::getLabel, this);
+    registerHybridSetter("label", &GPUBuffer::setLabel, this);
   }
 
+  inline const wgpu::Buffer get() { return _instance; }
+
 private:
   wgpu::Buffer _instance;
+  std::shared_ptr<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
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -0,0 +1,63 @@
+#include "GPUCanvasContext.h"
+#include "Convertors.h"
+#include "RNWebGPUManager.h"
+
+namespace rnwgpu {
+
+void GPUCanvasContext::configure(
+    std::shared_ptr<GPUCanvasConfiguration> configuration) {
+  Convertor conv;
+  wgpu::SurfaceConfiguration surfaceConfiguration;
+  surfaceConfiguration.device = configuration->device->get();
+  _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.format, configuration->format)) {
+    throw std::runtime_error("Error with SurfaceConfiguration");
+  }
+  if (!conv(surfaceConfiguration.usage, configuration->usage)) {
+    throw std::runtime_error("Error with SurfaceConfiguration");
+  }
+  surfaceConfiguration.width = _canvas->getWidth();
+  surfaceConfiguration.height = _canvas->getHeight();
+  _instance.Configure(&surfaceConfiguration);
+  _lastConfig = configuration;
+  _width = _canvas->getWidth();
+  _height = _canvas->getHeight();
+}
+
+void GPUCanvasContext::unconfigure() {
+  _lastConfig = nullptr;
+  _width = _canvas->getWidth();
+  _height = _canvas->getHeight();
+  _instance.Unconfigure();
+}
+
+std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
+  // we need to reconfigure if the size of the canvas has changed
+  if (_width != _canvas->getWidth() || _height != _canvas->getHeight()) {
+    configure(_lastConfig);
+  }
+  wgpu::SurfaceTexture surfaceTexture;
+  _instance.GetCurrentTexture(&surfaceTexture);
+  auto texture = surfaceTexture.texture;
+  if (texture == nullptr) {
+    throw std::runtime_error("Couldn't get current texture");
+  }
+  // Default canvas texture label is ""
+  return std::make_shared<GPUTexture>(texture, "");
+}
+
+void GPUCanvasContext::present() {
+#ifdef __APPLE__
+  dawn::native::metal::WaitForCommandsToBeScheduled(_device.Get());
+#endif
+  _instance.Present();
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -1,33 +1,76 @@
 #pragma once
 
-#include <future>
 #include <memory>
 #include <string>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
-
-#include "MutableBuffer.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
+
+#include "Canvas.h"
+#include "GPUCanvasConfiguration.h"
+#include "GPUTexture.h"
+#include "SurfaceRegistry.h"
+
+#ifdef __APPLE__
+
+namespace dawn {
+namespace native {
+namespace metal {
+
+// See
+// https://source.chromium.org/chromium/chromium/src/+/main:third_party/dawn/include/dawn/native/MetalBackend.h;l=41
+void WaitForCommandsToBeScheduled(WGPUDevice device);
+
+} // namespace metal
+} // namespace native
+} // namespace dawn
+
+#endif
+
 namespace rnwgpu {
 
 namespace m = margelo;
 
 class GPUCanvasContext : public m::HybridObject {
 public:
-  explicit GPUCanvasContext(wgpu::CanvasContext instance)
-      : HybridObject("GPUCanvasContext"), _instance(instance) {}
+  explicit GPUCanvasContext(wgpu::Surface instance,
+                            std::shared_ptr<Canvas> canvas)
+      : HybridObject("GPUCanvasContext"), _instance(instance), _canvas(canvas) {
+  }
 
 public:
   std::string getBrand() { return _name; }
 
+  std::shared_ptr<Canvas> getCanvas() { return _canvas; }
+
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUCanvasContext::getBrand, this);
+    registerHybridGetter("canvas", &GPUCanvasContext::getCanvas, this);
+    registerHybridMethod("configure", &GPUCanvasContext::configure, this);
+    registerHybridMethod("unconfigure", &GPUCanvasContext::unconfigure, this);
+    registerHybridMethod("getCurrentTexture",
+                         &GPUCanvasContext::getCurrentTexture, this);
+    registerHybridMethod("present", &GPUCanvasContext::present, this);
   }
 
+  inline const wgpu::Surface get() { return _instance; }
+  void configure(std::shared_ptr<GPUCanvasConfiguration> configuration);
+  void unconfigure();
+  std::shared_ptr<GPUTexture> getCurrentTexture();
+  void present();
+
 private:
-  wgpu::CanvasContext _instance;
+  wgpu::Surface _instance;
+  wgpu::Device _device;
+  std::shared_ptr<Canvas> _canvas;
+  std::shared_ptr<GPUCanvasConfiguration> _lastConfig;
+  float _width;
+  float _height;
 };
-} // namespace rnwgpu
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCommandBuffer.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", &GPUCommandBuffer::getBrand, this);
 
     registerHybridGetter("label", &GPUCommandBuffer::getLabel, this);
+    registerHybridSetter("label", &GPUCommandBuffer::setLabel, this);
   }
 
+  inline const wgpu::CommandBuffer get() { return _instance; }
+
 private:
   wgpu::CommandBuffer _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCommandEncoder.cpp

@@ -0,0 +1,177 @@
+#include "GPUCommandEncoder.h"
+
+#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::RenderPassDescriptorMaxDrawCount 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::ImageCopyTexture src{};
+  wgpu::ImageCopyBuffer 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::ImageCopyTexture src{};
+  wgpu::ImageCopyTexture 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::ImageCopyBuffer src{};
+  wgpu::ImageCopyTexture 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

package/cpp/rnwgpu/api/GPUCommandEncoder.h

@@ -1,16 +1,28 @@
 #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 "GPUBuffer.h"
+#include "GPUCommandBuffer.h"
+#include "GPUCommandBufferDescriptor.h"
+#include "GPUComputePassDescriptor.h"
+#include "GPUComputePassEncoder.h"
+#include "GPUExtent3D.h"
+#include "GPUImageCopyBuffer.h"
+#include "GPUImageCopyTexture.h"
+#include "GPUQuerySet.h"
+#include "GPURenderPassDescriptor.h"
+#include "GPURenderPassEncoder.h"
+
 namespace rnwgpu {
 
 namespace m = margelo;
@@ -23,16 +35,76 @@ public:
 public:
   std::string getBrand() { return _name; }
 
+  std::shared_ptr<GPURenderPassEncoder>
+  beginRenderPass(std::shared_ptr<GPURenderPassDescriptor> descriptor);
+  std::shared_ptr<GPUComputePassEncoder> beginComputePass(
+      std::optional<std::shared_ptr<GPUComputePassDescriptor>> descriptor);
+  void copyBufferToBuffer(std::shared_ptr<GPUBuffer> source,
+                          uint64_t sourceOffset,
+                          std::shared_ptr<GPUBuffer> destination,
+                          uint64_t destinationOffset, uint64_t size);
+  void copyBufferToTexture(std::shared_ptr<GPUImageCopyBuffer> source,
+                           std::shared_ptr<GPUImageCopyTexture> destination,
+                           std::shared_ptr<GPUExtent3D> copySize);
+  void copyTextureToBuffer(std::shared_ptr<GPUImageCopyTexture> source,
+                           std::shared_ptr<GPUImageCopyBuffer> destination,
+                           std::shared_ptr<GPUExtent3D> copySize);
+  void copyTextureToTexture(std::shared_ptr<GPUImageCopyTexture> source,
+                            std::shared_ptr<GPUImageCopyTexture> destination,
+                            std::shared_ptr<GPUExtent3D> copySize);
+  void clearBuffer(std::shared_ptr<GPUBuffer> buffer,
+                   std::optional<uint64_t> offset,
+                   std::optional<uint64_t> size);
+  void resolveQuerySet(std::shared_ptr<GPUQuerySet> querySet,
+                       uint32_t firstQuery, uint32_t queryCount,
+                       std::shared_ptr<GPUBuffer> destination,
+                       uint64_t destinationOffset);
+  std::shared_ptr<GPUCommandBuffer>
+  finish(std::optional<std::shared_ptr<GPUCommandBufferDescriptor>> descriptor);
+  void pushDebugGroup(std::string groupLabel);
+  void popDebugGroup();
+  void insertDebugMarker(std::string markerLabel);
+
   std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
 
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUCommandEncoder::getBrand, this);
+    registerHybridMethod("beginRenderPass", &GPUCommandEncoder::beginRenderPass,
+                         this);
+    registerHybridMethod("beginComputePass",
+                         &GPUCommandEncoder::beginComputePass, this);
+    registerHybridMethod("copyBufferToBuffer",
+                         &GPUCommandEncoder::copyBufferToBuffer, this);
+    registerHybridMethod("copyBufferToTexture",
+                         &GPUCommandEncoder::copyBufferToTexture, this);
+    registerHybridMethod("copyTextureToBuffer",
+                         &GPUCommandEncoder::copyTextureToBuffer, this);
+    registerHybridMethod("copyTextureToTexture",
+                         &GPUCommandEncoder::copyTextureToTexture, this);
+    registerHybridMethod("clearBuffer", &GPUCommandEncoder::clearBuffer, this);
+    registerHybridMethod("resolveQuerySet", &GPUCommandEncoder::resolveQuerySet,
+                         this);
+    registerHybridMethod("finish", &GPUCommandEncoder::finish, this);
+    registerHybridMethod("pushDebugGroup", &GPUCommandEncoder::pushDebugGroup,
+                         this);
+    registerHybridMethod("popDebugGroup", &GPUCommandEncoder::popDebugGroup,
+                         this);
+    registerHybridMethod("insertDebugMarker",
+                         &GPUCommandEncoder::insertDebugMarker, this);
 
     registerHybridGetter("label", &GPUCommandEncoder::getLabel, this);
+    registerHybridSetter("label", &GPUCommandEncoder::setLabel, this);
   }
 
+  inline const wgpu::CommandEncoder get() { return _instance; }
+
 private:
   wgpu::CommandEncoder _instance;
   std::string _label;
 };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <future>
-#include <memory>
 #include <string>
+#include <vector>
 
 #include "Unions.h"
-#include <RNFHybridObject.h>
 
-#include "MutableBuffer.h"
+#include "RNFHybridObject.h"
+
+#include "AsyncRunner.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -15,19 +15,76 @@ namespace rnwgpu {
 
 namespace m = margelo;
 
+struct GPUCompilationMessage {
+  std::string message;
+  wgpu::CompilationMessageType type;
+  uint64_t lineNum;
+  uint64_t linePos;
+  uint64_t offset;
+  uint64_t length;
+  uint64_t utf16LinePos;
+  uint64_t utf16Offset;
+  uint64_t utf16Length;
+};
+
 class GPUCompilationInfo : public m::HybridObject {
 public:
-  explicit GPUCompilationInfo(wgpu::CompilationInfo instance)
-      : HybridObject("GPUCompilationInfo"), _instance(instance) {}
+  GPUCompilationInfo() : HybridObject("GPUCompilationInfo") {}
 
 public:
   std::string getBrand() { return _name; }
 
+  std::vector<GPUCompilationMessage> getMessages() { return _messages; }
+
   void loadHybridMethods() override {
     registerHybridGetter("__brand", &GPUCompilationInfo::getBrand, this);
+    registerHybridGetter("messages", &GPUCompilationInfo::getMessages, this);
   }
 
 private:
-  wgpu::CompilationInfo _instance;
+  std::vector<GPUCompilationMessage> _messages;
+  friend class GPUShaderModule;
+};
+
+} // namespace rnwgpu
+
+namespace margelo {
+template <> struct JSIConverter<std::vector<rnwgpu::GPUCompilationMessage>> {
+  static std::vector<rnwgpu::GPUCompilationMessage>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    throw std::runtime_error("Invalid GPUCompilationMessage::fromJSI()");
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::vector<rnwgpu::GPUCompilationMessage> arg) {
+    jsi::Array result = jsi::Array(runtime, arg.size());
+    for (size_t i = 0; i < arg.size(); i++) {
+      const auto &message = arg[i];
+      jsi::Object messageObj(runtime);
+      messageObj.setProperty(
+          runtime, "message",
+          jsi::String::createFromUtf8(runtime, message.message));
+      std::string typeStr;
+      EnumMapper::convertEnumToJSUnion(message.type, &typeStr);
+      messageObj.setProperty(runtime, "type",
+                             jsi::String::createFromUtf8(runtime, typeStr));
+      messageObj.setProperty(runtime, "lineNum",
+                             static_cast<double>(message.lineNum));
+      messageObj.setProperty(runtime, "linePos",
+                             static_cast<double>(message.linePos));
+      messageObj.setProperty(runtime, "offset",
+                             static_cast<double>(message.offset));
+      messageObj.setProperty(runtime, "length",
+                             static_cast<double>(message.length));
+      messageObj.setProperty(runtime, "utf16LinePos",
+                             static_cast<double>(message.utf16LinePos));
+      messageObj.setProperty(runtime, "utf16Offset",
+                             static_cast<double>(message.utf16Offset));
+      messageObj.setProperty(runtime, "utf16Length",
+                             static_cast<double>(message.utf16Length));
+      result.setValueAtIndex(runtime, i, messageObj);
+    }
+    return result;
+  }
 };
-} // namespace rnwgpu
+
+} // namespace margelo

package/cpp/rnwgpu/api/GPUCompilationMessage.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"
 
@@ -27,7 +26,10 @@ public:
     registerHybridGetter("__brand", &GPUCompilationMessage::getBrand, this);
   }
 
+  inline const wgpu::CompilationMessage get() { return _instance; }
+
 private:
   wgpu::CompilationMessage _instance;
 };
+
 } // namespace rnwgpu