react-native-wgpu 0.2.0 → 0.2.2

package/cpp/dawn/webgpu_cpp_print.h

@@ -341,6 +341,35 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, ComponentSwizzle value) {
+      switch (value) {
+      case ComponentSwizzle::Undefined:
+        o << "ComponentSwizzle::Undefined";
+        break;
+      case ComponentSwizzle::Zero:
+        o << "ComponentSwizzle::Zero";
+        break;
+      case ComponentSwizzle::One:
+        o << "ComponentSwizzle::One";
+        break;
+      case ComponentSwizzle::R:
+        o << "ComponentSwizzle::R";
+        break;
+      case ComponentSwizzle::G:
+        o << "ComponentSwizzle::G";
+        break;
+      case ComponentSwizzle::B:
+        o << "ComponentSwizzle::B";
+        break;
+      case ComponentSwizzle::A:
+        o << "ComponentSwizzle::A";
+        break;
+          default:
+            o << "ComponentSwizzle::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<ComponentSwizzle>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, CompositeAlphaMode value) {
       switch (value) {
       case CompositeAlphaMode::Auto:
@@ -424,6 +453,20 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, DynamicBindingKind value) {
+      switch (value) {
+      case DynamicBindingKind::Undefined:
+        o << "DynamicBindingKind::Undefined";
+        break;
+      case DynamicBindingKind::SampledTexture:
+        o << "DynamicBindingKind::SampledTexture";
+        break;
+          default:
+            o << "DynamicBindingKind::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<DynamicBindingKind>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, ErrorFilter value) {
       switch (value) {
       case ErrorFilter::Validation:
@@ -503,15 +546,15 @@ namespace wgpu {
   template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, FeatureName value) {
       switch (value) {
+      case FeatureName::CoreFeaturesAndLimits:
+        o << "FeatureName::CoreFeaturesAndLimits";
+        break;
       case FeatureName::DepthClipControl:
         o << "FeatureName::DepthClipControl";
         break;
       case FeatureName::Depth32FloatStencil8:
         o << "FeatureName::Depth32FloatStencil8";
         break;
-      case FeatureName::TimestampQuery:
-        o << "FeatureName::TimestampQuery";
-        break;
       case FeatureName::TextureCompressionBC:
         o << "FeatureName::TextureCompressionBC";
         break;
@@ -527,6 +570,9 @@ namespace wgpu {
       case FeatureName::TextureCompressionASTCSliced3D:
         o << "FeatureName::TextureCompressionASTCSliced3D";
         break;
+      case FeatureName::TimestampQuery:
+        o << "FeatureName::TimestampQuery";
+        break;
       case FeatureName::IndirectFirstInstance:
         o << "FeatureName::IndirectFirstInstance";
         break;
@@ -554,8 +600,14 @@ namespace wgpu {
       case FeatureName::Subgroups:
         o << "FeatureName::Subgroups";
         break;
-      case FeatureName::CoreFeaturesAndLimits:
-        o << "FeatureName::CoreFeaturesAndLimits";
+      case FeatureName::TextureFormatsTier1:
+        o << "FeatureName::TextureFormatsTier1";
+        break;
+      case FeatureName::TextureFormatsTier2:
+        o << "FeatureName::TextureFormatsTier2";
+        break;
+      case FeatureName::PrimitiveIndex:
+        o << "FeatureName::PrimitiveIndex";
         break;
       case FeatureName::DawnInternalUsages:
         o << "FeatureName::DawnInternalUsages";
@@ -727,6 +779,12 @@ namespace wgpu {
         break;
       case FeatureName::DawnDeviceAllocatorControl:
         o << "FeatureName::DawnDeviceAllocatorControl";
+        break;
+      case FeatureName::TextureComponentSwizzle:
+        o << "FeatureName::TextureComponentSwizzle";
+        break;
+      case FeatureName::ChromiumExperimentalBindless:
+        o << "FeatureName::ChromiumExperimentalBindless";
         break;
           default:
             o << "FeatureName::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<FeatureName>::type>(value);
@@ -785,6 +843,23 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, InstanceFeatureName value) {
+      switch (value) {
+      case InstanceFeatureName::TimedWaitAny:
+        o << "InstanceFeatureName::TimedWaitAny";
+        break;
+      case InstanceFeatureName::ShaderSourceSPIRV:
+        o << "InstanceFeatureName::ShaderSourceSPIRV";
+        break;
+      case InstanceFeatureName::MultipleDevicesPerAdapter:
+        o << "InstanceFeatureName::MultipleDevicesPerAdapter";
+        break;
+          default:
+            o << "InstanceFeatureName::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<InstanceFeatureName>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, LoadOp value) {
       switch (value) {
       case LoadOp::Undefined:
@@ -896,6 +971,20 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, PredefinedColorSpace value) {
+      switch (value) {
+      case PredefinedColorSpace::SRGB:
+        o << "PredefinedColorSpace::SRGB";
+        break;
+      case PredefinedColorSpace::DisplayP3:
+        o << "PredefinedColorSpace::DisplayP3";
+        break;
+          default:
+            o << "PredefinedColorSpace::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<PredefinedColorSpace>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, PresentMode value) {
       switch (value) {
       case PresentMode::Undefined:
@@ -1180,8 +1269,14 @@ namespace wgpu {
       case SType::SurfaceSourceXCBWindow:
         o << "SType::SurfaceSourceXCBWindow";
         break;
-      case SType::AdapterPropertiesSubgroups:
-        o << "SType::AdapterPropertiesSubgroups";
+      case SType::SurfaceColorManagement:
+        o << "SType::SurfaceColorManagement";
+        break;
+      case SType::RequestAdapterWebXROptions:
+        o << "SType::RequestAdapterWebXROptions";
+        break;
+      case SType::CompatibilityModeLimits:
+        o << "SType::CompatibilityModeLimits";
         break;
       case SType::TextureBindingViewDimensionDescriptor:
         o << "SType::TextureBindingViewDimensionDescriptor";
@@ -1392,6 +1487,33 @@ namespace wgpu {
         break;
       case SType::RequestAdapterWebGPUBackendOptions:
         o << "SType::RequestAdapterWebGPUBackendOptions";
+        break;
+      case SType::DawnFakeDeviceInitializeErrorForTesting:
+        o << "SType::DawnFakeDeviceInitializeErrorForTesting";
+        break;
+      case SType::TextureComponentSwizzleDescriptor:
+        o << "SType::TextureComponentSwizzleDescriptor";
+        break;
+      case SType::SharedTextureMemoryD3D11BeginState:
+        o << "SType::SharedTextureMemoryD3D11BeginState";
+        break;
+      case SType::DawnConsumeAdapterDescriptor:
+        o << "SType::DawnConsumeAdapterDescriptor";
+        break;
+      case SType::BindGroupLayoutDynamicBindingArray:
+        o << "SType::BindGroupLayoutDynamicBindingArray";
+        break;
+      case SType::DynamicBindingArrayLimits:
+        o << "SType::DynamicBindingArrayLimits";
+        break;
+      case SType::BindGroupDynamicBindingArray:
+        o << "SType::BindGroupDynamicBindingArray";
+        break;
+      case SType::TexelBufferBindingEntry:
+        o << "SType::TexelBufferBindingEntry";
+        break;
+      case SType::TexelBufferBindingLayout:
+        o << "SType::TexelBufferBindingLayout";
         break;
           default:
             o << "SType::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<SType>::type>(value);
@@ -1412,6 +1534,12 @@ namespace wgpu {
         break;
       case SubgroupMatrixComponentType::I32:
         o << "SubgroupMatrixComponentType::I32";
+        break;
+      case SubgroupMatrixComponentType::U8:
+        o << "SubgroupMatrixComponentType::U8";
+        break;
+      case SubgroupMatrixComponentType::I8:
+        o << "SubgroupMatrixComponentType::I8";
         break;
           default:
             o << "SubgroupMatrixComponentType::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<SubgroupMatrixComponentType>::type>(value);
@@ -1445,6 +1573,23 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, TexelBufferAccess value) {
+      switch (value) {
+      case TexelBufferAccess::Undefined:
+        o << "TexelBufferAccess::Undefined";
+        break;
+      case TexelBufferAccess::ReadOnly:
+        o << "TexelBufferAccess::ReadOnly";
+        break;
+      case TexelBufferAccess::ReadWrite:
+        o << "TexelBufferAccess::ReadWrite";
+        break;
+          default:
+            o << "TexelBufferAccess::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<TexelBufferAccess>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, TextureAspect value) {
       switch (value) {
       case TextureAspect::Undefined:
@@ -1511,6 +1656,12 @@ namespace wgpu {
       case TextureFormat::R8Sint:
         o << "TextureFormat::R8Sint";
         break;
+      case TextureFormat::R16Unorm:
+        o << "TextureFormat::R16Unorm";
+        break;
+      case TextureFormat::R16Snorm:
+        o << "TextureFormat::R16Snorm";
+        break;
       case TextureFormat::R16Uint:
         o << "TextureFormat::R16Uint";
         break;
@@ -1541,6 +1692,12 @@ namespace wgpu {
       case TextureFormat::R32Sint:
         o << "TextureFormat::R32Sint";
         break;
+      case TextureFormat::RG16Unorm:
+        o << "TextureFormat::RG16Unorm";
+        break;
+      case TextureFormat::RG16Snorm:
+        o << "TextureFormat::RG16Snorm";
+        break;
       case TextureFormat::RG16Uint:
         o << "TextureFormat::RG16Uint";
         break;
@@ -1592,6 +1749,12 @@ namespace wgpu {
       case TextureFormat::RG32Sint:
         o << "TextureFormat::RG32Sint";
         break;
+      case TextureFormat::RGBA16Unorm:
+        o << "TextureFormat::RGBA16Unorm";
+        break;
+      case TextureFormat::RGBA16Snorm:
+        o << "TextureFormat::RGBA16Snorm";
+        break;
       case TextureFormat::RGBA16Uint:
         o << "TextureFormat::RGBA16Uint";
         break;
@@ -1784,24 +1947,6 @@ namespace wgpu {
       case TextureFormat::ASTC12x12UnormSrgb:
         o << "TextureFormat::ASTC12x12UnormSrgb";
         break;
-      case TextureFormat::R16Unorm:
-        o << "TextureFormat::R16Unorm";
-        break;
-      case TextureFormat::RG16Unorm:
-        o << "TextureFormat::RG16Unorm";
-        break;
-      case TextureFormat::RGBA16Unorm:
-        o << "TextureFormat::RGBA16Unorm";
-        break;
-      case TextureFormat::R16Snorm:
-        o << "TextureFormat::R16Snorm";
-        break;
-      case TextureFormat::RG16Snorm:
-        o << "TextureFormat::RG16Snorm";
-        break;
-      case TextureFormat::RGBA16Snorm:
-        o << "TextureFormat::RGBA16Snorm";
-        break;
       case TextureFormat::R8BG8Biplanar420Unorm:
         o << "TextureFormat::R8BG8Biplanar420Unorm";
         break;
@@ -1890,6 +2035,20 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, ToneMappingMode value) {
+      switch (value) {
+      case ToneMappingMode::Standard:
+        o << "ToneMappingMode::Standard";
+        break;
+      case ToneMappingMode::Extended:
+        o << "ToneMappingMode::Extended";
+        break;
+          default:
+            o << "ToneMappingMode::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<ToneMappingMode>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, VertexFormat value) {
       switch (value) {
       case VertexFormat::Uint8:
@@ -2072,6 +2231,12 @@ namespace wgpu {
       case WGSLLanguageFeatureName::SizedBindingArray:
         o << "WGSLLanguageFeatureName::SizedBindingArray";
         break;
+      case WGSLLanguageFeatureName::TexelBuffers:
+        o << "WGSLLanguageFeatureName::TexelBuffers";
+        break;
+      case WGSLLanguageFeatureName::ChromiumPrint:
+        o << "WGSLLanguageFeatureName::ChromiumPrint";
+        break;
       case WGSLLanguageFeatureName::ChromiumTestingUnimplemented:
         o << "WGSLLanguageFeatureName::ChromiumTestingUnimplemented";
         break;
@@ -2188,6 +2353,14 @@ namespace wgpu {
     o << "QueryResolve";
     value &= ~BufferUsage::QueryResolve;
   }
+  if (value & BufferUsage::TexelBuffer) {
+    if (!first) {
+      o << "|";
+    }
+    first = false;
+    o << "TexelBuffer";
+    value &= ~BufferUsage::TexelBuffer;
+  }
 
     if (static_cast<bool>(value)) {
       if (!first) {
@@ -2518,6 +2691,10 @@ namespace wgpu {
     return o;
   }
 
+}  // namespace wgpu
+
+namespace wgpu {
+
   template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, StringView value) {
       o << std::string_view(value);

package/cpp/dawn_logging.cpp

@@ -1,5 +1,7 @@
+#include <cstdio>
 #include <sstream>
 #include <string>
+#include <utility>
 
 #ifdef __ANDROID__
 #include <android/log.h>
@@ -21,10 +23,8 @@ class LogMessage {
 public:
     explicit LogMessage(LogSeverity severity);
     ~LogMessage();
-    
     LogMessage(LogMessage&& other);
     LogMessage& operator=(LogMessage&& other);
-    
     template <typename T>
     LogMessage& operator<<(T&& value) {
         mStream << value;
@@ -34,7 +34,6 @@ public:
 private:
     LogMessage(const LogMessage& other) = delete;
     LogMessage& operator=(const LogMessage& other) = delete;
-    
     LogSeverity mSeverity;
     std::ostringstream mStream;
 };
@@ -42,7 +41,7 @@ private:
 // Implementation of LogMessage methods
 LogMessage::LogMessage(LogSeverity severity) : mSeverity(severity) {}
 
-LogMessage::LogMessage(LogMessage&& other) 
+LogMessage::LogMessage(LogMessage&& other)
     : mSeverity(other.mSeverity), mStream(std::move(other.mStream)) {}
 
 LogMessage& LogMessage::operator=(LogMessage&& other) {
@@ -55,11 +54,9 @@ LogMessage& LogMessage::operator=(LogMessage&& other) {
 
 LogMessage::~LogMessage() {
     std::string fullMessage = mStream.str();
-    
     if (fullMessage.empty()) {
         return;
     }
-    
     const char* severityName;
     switch (mSeverity) {
         case LogSeverity::Debug: severityName = "Debug"; break;

package/cpp/jsi/RNFHybridObject.cpp

@@ -5,9 +5,10 @@
 #include "RNFJSIConverter.h"
 #include "WGPULogger.h"
 
-#include <vector>
+#include <unordered_map>
 #include <utility>
 #include <string>
+#include <vector>
 
 namespace margelo {
 

package/cpp/jsi/RNFJSIConverter.h

@@ -28,6 +28,9 @@
 #include "Dispatcher.h"
 #include "ThreadPool.h"
 
+// This number is the maximum integer that can be represented exactly as a double
+#define MAX_SAFE_INTEGER static_cast<uint64_t>(9007199254740991)
+
 #if __has_include(<cxxabi.h>)
 #include <cxxabi.h>
 #endif
@@ -122,7 +125,7 @@ template <> struct JSIConverter<uint64_t> {
   static uint64_t fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
     if (arg.isNumber()) {
       double value = arg.asNumber();
-      if (value < 0 || value > static_cast<double>(std::numeric_limits<uint64_t>::max())) {
+      if (value < 0 || value > MAX_SAFE_INTEGER) {
         throw jsi::JSError(runtime, "Number out of range for uint64_t");
       }
       return static_cast<uint64_t>(value);
@@ -132,7 +135,7 @@ template <> struct JSIConverter<uint64_t> {
   }
 
   static jsi::Value toJSI(jsi::Runtime& runtime, uint64_t arg) {
-    if (arg <= static_cast<uint64_t>(std::numeric_limits<double>::max())) {
+    if (arg <= MAX_SAFE_INTEGER) {
       return jsi::Value(static_cast<double>(arg));
     } else {
       throw jsi::JSError(runtime, "Number too large to be represented as a double");

package/cpp/jsi/RNFPromise.cpp

@@ -4,6 +4,8 @@
 #include "RNFPromise.h"
 #include <future>
 #include <jsi/jsi.h>
+#include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 

package/cpp/jsi/RNFWorkletRuntimeRegistry.cpp

@@ -2,6 +2,7 @@
 // Created by Marc Rousavy on 22.02.24.
 //
 #include "RNFWorkletRuntimeRegistry.h"
+#include <set>
 
 namespace margelo {
 

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -3,6 +3,7 @@
 #include <memory>
 #include <shared_mutex>
 #include <unordered_map>
+#include <utility>
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPU.cpp

@@ -1,5 +1,9 @@
 #include "GPU.h"
 
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -50,7 +54,7 @@ GPU::requestAdapter(
 std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
   wgpu::SupportedWGSLLanguageFeatures supportedFeatures = {};
   _instance.GetWGSLLanguageFeatures(&supportedFeatures);
-  
+
   std::unordered_set<std::string> result;
   for (size_t i = 0; i < supportedFeatures.featureCount; i++) {
     wgpu::WGSLLanguageFeatureName feature = supportedFeatures.features[i];

package/cpp/rnwgpu/api/GPU.h

@@ -28,9 +28,13 @@ namespace m = margelo;
 class GPU : public m::HybridObject {
 public:
   GPU() : HybridObject("GPU") {
-    wgpu::InstanceDescriptor instanceDesc;
-    instanceDesc.capabilities.timedWaitAnyEnable = true;
-    instanceDesc.capabilities.timedWaitAnyMaxCount = 64;
+    static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
+    wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
+                                          .requiredFeatures = &kTimedWaitAny};
+
+    // For limits:
+    wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
+    instanceDesc.requiredLimits = &limits;
     _instance = wgpu::CreateInstance(&instanceDesc);
     auto instance = &_instance;
     _async = std::make_shared<AsyncRunner>(instance);

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -1,6 +1,9 @@
 #include "GPUAdapter.h"
 
+#include <cstdio>
+#include <memory>
 #include <string>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -1,5 +1,6 @@
 #include "GPUBuffer.h"
 
+#include <memory>
 #include <utility>
 
 #include "Convertors.h"

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -1,4 +1,5 @@
 #include "GPUCanvasContext.h"
+#include <memory>
 #include "Convertors.h"
 #include "RNWebGPUManager.h"
 

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "Unions.h"
 

package/cpp/rnwgpu/api/GPUCommandEncoder.cpp

@@ -1,5 +1,7 @@
 #include "GPUCommandEncoder.h"
 
+#include <memory>
+#include <string>
 #include <vector>
 
 #include "Convertors.h"

package/cpp/rnwgpu/api/GPUComputePassEncoder.cpp

@@ -1,4 +1,6 @@
 #include "GPUComputePassEncoder.h"
+#include <memory>
+#include <string>
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUComputePipeline.cpp

@@ -1,4 +1,5 @@
 #include "GPUComputePipeline.h"
+#include <memory>
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -1,5 +1,8 @@
 #include "GPUDevice.h"
 
+#include <memory>
+#include <string>
+#include <unordered_set>
 #include <vector>
 
 #include "Convertors.h"

package/cpp/rnwgpu/api/GPUDeviceLostInfo.cpp

@@ -1,4 +1,5 @@
 #include "GPUDeviceLostInfo.h"
+#include <string>
 
 namespace rnwgpu {
 wgpu::DeviceLostReason getReason();

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -1,6 +1,8 @@
 #include "GPUQueue.h"
 
 #include <limits>
+#include <memory>
+#include <vector>
 
 #include "Convertors.h"
 
@@ -38,7 +40,7 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
 
   // Note that in the JS semantics of WebGPU, writeBuffer works in number of
   // elements of the typed arrays.
-  if (dataOffsetElements > uint64_t(src.size / src.bytesPerElement)) {
+  if (dataOffsetElements > static_cast<uint64_t>(src.size / src.bytesPerElement)) {
     throw std::runtime_error("dataOffset is larger than data's size.");
     return;
   }
@@ -49,7 +51,7 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
   // 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 = uint64_t(src.size);
+  uint64_t size64 = static_cast<uint64_t>(src.size);
   if (sizeElements.has_value()) {
     if (sizeElements.value() >
         std::numeric_limits<uint64_t>::max() / src.bytesPerElement) {
@@ -59,7 +61,7 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
     size64 = sizeElements.value() * src.bytesPerElement;
   }
 
-  if (size64 > uint64_t(src.size)) {
+  if (size64 > static_cast<uint64_t>(src.size)) {
     throw std::runtime_error("size + dataOffset is larger than data's size.");
     return;
   }
@@ -76,10 +78,12 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
 }
 
 std::future<void> GPUQueue::onSubmittedWorkDone() {
-  return _async->runAsync([=] {
+  return _async->runAsync([&] {
     return _instance.OnSubmittedWorkDone(
         wgpu::CallbackMode::WaitAnyOnly,
-        [](wgpu::QueueWorkDoneStatus status) {});
+        [](wgpu::QueueWorkDoneStatus status, wgpu::StringView message) {
+          // Handle the callback if needed
+        });
   });
 }
 

package/cpp/rnwgpu/api/GPURenderBundleEncoder.cpp

@@ -1,5 +1,8 @@
 #include "GPURenderBundleEncoder.h"
 
+#include <memory>
+#include <string>
+
 #include "Convertors.h"
 
 namespace rnwgpu {

package/cpp/rnwgpu/api/GPURenderPassEncoder.cpp

@@ -1,3 +1,7 @@
+#include <vector>
+#include <string>
+#include <memory>
+
 #include "GPURenderPassEncoder.h"
 #include "Convertors.h"
 

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -1,6 +1,7 @@
 #include "GPUShaderModule.h"
 
 #include <utility>
+#include <memory>
 
 namespace rnwgpu {