react-native-wgpu 0.1.23 → 0.2.1

package/cpp/rnwgpu/api/GPUCommandEncoder.cpp

@@ -64,8 +64,8 @@ void GPUCommandEncoder::copyTextureToBuffer(
     std::shared_ptr<GPUImageCopyBuffer> destination,
     std::shared_ptr<GPUExtent3D> copySize) {
   Convertor conv;
-  wgpu::ImageCopyTexture src{};
-  wgpu::ImageCopyBuffer dst{};
+  wgpu::TexelCopyTextureInfo src{};
+  wgpu::TexelCopyBufferInfo dst{};
   wgpu::Extent3D size{};
   if (!conv(src, source) ||      //
       !conv(dst, destination) || //
@@ -81,8 +81,8 @@ void GPUCommandEncoder::copyTextureToTexture(
     std::shared_ptr<GPUExtent3D> copySize) {
   Convertor conv;
 
-  wgpu::ImageCopyTexture src{};
-  wgpu::ImageCopyTexture dst{};
+  wgpu::TexelCopyTextureInfo src{};
+  wgpu::TexelCopyTextureInfo dst{};
   wgpu::Extent3D size{};
   if (!conv(src, source) ||      //
       !conv(dst, destination) || //
@@ -137,8 +137,8 @@ void GPUCommandEncoder::copyBufferToTexture(
     std::shared_ptr<GPUExtent3D> copySize) {
   Convertor conv;
 
-  wgpu::ImageCopyBuffer src{};
-  wgpu::ImageCopyTexture dst{};
+  wgpu::TexelCopyBufferInfo src{};
+  wgpu::TexelCopyTextureInfo dst{};
   wgpu::Extent3D size{};
   if (!conv(src, source) ||      //
       !conv(dst, destination) || //

package/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -22,9 +22,6 @@ struct GPUCompilationMessage {
   uint64_t linePos;
   uint64_t offset;
   uint64_t length;
-  uint64_t utf16LinePos;
-  uint64_t utf16Offset;
-  uint64_t utf16Length;
 };
 
 class GPUCompilationInfo : public m::HybridObject {
@@ -75,12 +72,6 @@ template <> struct JSIConverter<std::vector<rnwgpu::GPUCompilationMessage>> {
                              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;

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -22,7 +22,7 @@ GPUDevice::createBuffer(std::shared_ptr<GPUBufferDescriptor> descriptor) {
 }
 
 std::shared_ptr<GPUSupportedLimits> GPUDevice::getLimits() {
-  wgpu::SupportedLimits limits{};
+  wgpu::Limits limits{};
   if (!_instance.GetLimits(&limits)) {
     throw std::runtime_error("failed to get device limits");
   }
@@ -301,9 +301,8 @@ GPUDevice::popErrorScope() {
             break;
           }
           case wgpu::ErrorType::Unknown:
-          case wgpu::ErrorType::DeviceLost:
-            result = std::make_shared<GPUError>(wgpu::ErrorType::DeviceLost,
-                                                message);
+            result =
+                std::make_shared<GPUError>(wgpu::ErrorType::Unknown, message);
             break;
           default:
             throw std::runtime_error(
@@ -321,13 +320,11 @@ GPUDevice::popErrorScope() {
 }
 
 std::unordered_set<std::string> GPUDevice::getFeatures() {
-  size_t count = _instance.EnumerateFeatures(nullptr);
-  std::vector<wgpu::FeatureName> features(count);
-  if (count > 0) {
-    _instance.EnumerateFeatures(features.data());
-  }
+  wgpu::SupportedFeatures supportedFeatures;
+  _instance.GetFeatures(&supportedFeatures);
   std::unordered_set<std::string> result;
-  for (auto feature : features) {
+  for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
+    auto feature = supportedFeatures.features[i];
     std::string name;
     convertEnumToJSUnion(feature, &name);
     result.insert(name);

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -47,9 +47,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::Subgroups:
     *outUnion = "subgroups";
     break;
-  case wgpu::FeatureName::SubgroupsF16:
-    *outUnion = "subgroups-f16";
-    break;
   case wgpu::FeatureName::DawnInternalUsages:
     *outUnion = "dawn-internal-usages";
     break;
@@ -65,9 +62,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ImplicitDeviceSynchronization:
     *outUnion = "implicit-device-synchronization";
     break;
-    //  case wgpu::FeatureName::SurfaceCapabilities:
-    //    *outUnion = "surface-capabilities";
-    //    break;
   case wgpu::FeatureName::TransientAttachments:
     *outUnion = "transient-attachments";
     break;
@@ -83,11 +77,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ANGLETextureSharing:
     *outUnion = "angle-texture-sharing";
     break;
-  case wgpu::FeatureName::ChromiumExperimentalSubgroups:
-    *outUnion = "chromium-experimental-subgroups";
-    break;
-  case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow:
-    *outUnion = "chromium-experimental-subgroup-uniform-control-flow";
+  case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
+    *outUnion = "chromium-experimental-subgroups-matrix";
     break;
   case wgpu::FeatureName::PixelLocalStorageCoherent:
     *outUnion = "pixel-local-storage-coherent";
@@ -134,10 +125,10 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::R8UnormStorage:
     *outUnion = "r8unorm-storage";
     break;
-  case wgpu::FeatureName::FormatCapabilities:
+  case wgpu::FeatureName::DawnFormatCapabilities:
     *outUnion = "format-capabilities";
     break;
-  case wgpu::FeatureName::DrmFormatCapabilities:
+  case wgpu::FeatureName::DawnDrmFormatCapabilities:
     *outUnion = "drm-format-capabilities";
     break;
   case wgpu::FeatureName::Norm16TextureFormats:
@@ -185,7 +176,7 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
     *outUnion = "shared-fence-vk-semaphore-opaque-fd";
     break;
-  case wgpu::FeatureName::SharedFenceVkSemaphoreSyncFD:
+  case wgpu::FeatureName::SharedFenceSyncFD:
     *outUnion = "shared-fence-vk-semaphore-sync-fd";
     break;
   case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -87,8 +87,8 @@ void GPUQueue::copyExternalImageToTexture(
     std::shared_ptr<GPUImageCopyExternalImage> source,
     std::shared_ptr<GPUImageCopyTextureTagged> destination,
     std::shared_ptr<GPUExtent3D> size) {
-  wgpu::ImageCopyTexture dst{};
-  wgpu::TextureDataLayout layout{};
+  wgpu::TexelCopyTextureInfo dst{};
+  wgpu::TexelCopyBufferLayout layout{};
   wgpu::Extent3D sz{};
   Convertor conv;
   uint32_t bytesPerPixel =
@@ -137,8 +137,8 @@ void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
                             std::shared_ptr<ArrayBuffer> data,
                             std::shared_ptr<GPUImageDataLayout> dataLayout,
                             std::shared_ptr<GPUExtent3D> size) {
-  wgpu::ImageCopyTexture dst{};
-  wgpu::TextureDataLayout layout{};
+  wgpu::TexelCopyTextureInfo dst{};
+  wgpu::TexelCopyBufferLayout layout{};
   wgpu::Extent3D sz{};
   Convertor conv;
   if (!conv(dst, destination) ||   //

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -25,9 +25,6 @@ GPUShaderModule::getCompilationInfo() {
               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));
             }
           }

package/cpp/rnwgpu/api/GPUSupportedLimits.cpp

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

package/cpp/rnwgpu/api/GPUSupportedLimits.h

@@ -16,7 +16,7 @@ namespace m = margelo;
 
 class GPUSupportedLimits : public m::HybridObject {
 public:
-  explicit GPUSupportedLimits(wgpu::SupportedLimits instance)
+  explicit GPUSupportedLimits(wgpu::Limits instance)
       : HybridObject("GPUSupportedLimits"), _instance(instance) {}
 
 public:
@@ -44,7 +44,6 @@ public:
   double getMaxBufferSize();
   double getMaxVertexAttributes();
   double getMaxVertexBufferArrayStride();
-  double getMaxInterStageShaderComponents();
   double getMaxInterStageShaderVariables();
   double getMaxColorAttachments();
   double getMaxColorAttachmentBytesPerSample();
@@ -117,9 +116,6 @@ public:
     registerHybridGetter("maxVertexBufferArrayStride",
                          &GPUSupportedLimits::getMaxVertexBufferArrayStride,
                          this);
-    registerHybridGetter("maxInterStageShaderComponents",
-                         &GPUSupportedLimits::getMaxInterStageShaderComponents,
-                         this);
     registerHybridGetter("maxInterStageShaderVariables",
                          &GPUSupportedLimits::getMaxInterStageShaderVariables,
                          this);
@@ -148,10 +144,10 @@ public:
         &GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension, this);
   }
 
-  inline const wgpu::SupportedLimits get() { return _instance; }
+  inline const wgpu::Limits get() { return _instance; }
 
 private:
-  wgpu::SupportedLimits _instance;
+  wgpu::Limits _instance;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/Unions.h

@@ -434,8 +434,6 @@ static void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::Float32Filterable;
   } else if (inUnion == "subgroups") {
     *outEnum = wgpu::FeatureName::Subgroups;
-  } else if (inUnion == "subgroups-f16") {
-    *outEnum = wgpu::FeatureName::SubgroupsF16;
   } else if (inUnion == "dawn-internal-usages") {
     *outEnum = wgpu::FeatureName::DawnInternalUsages;
   } else if (inUnion == "dawn-multi-planar-formats") {
@@ -456,10 +454,8 @@ static void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::D3D11MultithreadProtected;
   } else if (inUnion == "angle-texture-sharing") {
     *outEnum = wgpu::FeatureName::ANGLETextureSharing;
-  } else if (inUnion == "chromium-experimental-subgroups") {
-    *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroups;
-  } else if (inUnion == "chromium-experimental-subgroup-uniform-control-flow") {
-    *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow;
+  } else if (inUnion == "chromium-experimental-subgroups-matrix") {
+    *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix;
   } else if (inUnion == "pixel-local-storage-coherent") {
     *outEnum = wgpu::FeatureName::PixelLocalStorageCoherent;
   } else if (inUnion == "pixel-local-storage-non-coherent") {
@@ -490,10 +486,8 @@ static void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::AdapterPropertiesVk;
   } else if (inUnion == "r8unorm-storage") {
     *outEnum = wgpu::FeatureName::R8UnormStorage;
-  } else if (inUnion == "format-capabilities") {
-    *outEnum = wgpu::FeatureName::FormatCapabilities;
-  } else if (inUnion == "drm-format-capabilities") {
-    *outEnum = wgpu::FeatureName::DrmFormatCapabilities;
+  } else if (inUnion == "dawn-format-capabilities") {
+    *outEnum = wgpu::FeatureName::DawnFormatCapabilities;
   } else if (inUnion == "norm16-texture-formats") {
     *outEnum = wgpu::FeatureName::Norm16TextureFormats;
   } else if (inUnion == "multi-planar-format-nv16") {
@@ -524,8 +518,6 @@ static void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::FeatureName::SharedTextureMemoryEGLImage;
   } else if (inUnion == "shared-fence-vk-semaphore-opaque-fd") {
     *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD;
-  } else if (inUnion == "shared-fence-vk-semaphore-sync-fd") {
-    *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreSyncFD;
   } else if (inUnion == "shared-fence-vk-semaphore-zircon-handle") {
     *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle;
   } else if (inUnion == "shared-fence-dxgi-shared-handle") {
@@ -588,9 +580,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::Subgroups:
     *outUnion = "subgroups";
     break;
-  case wgpu::FeatureName::SubgroupsF16:
-    *outUnion = "subgroups-f16";
-    break;
   case wgpu::FeatureName::DawnInternalUsages:
     *outUnion = "dawn-internal-usages";
     break;
@@ -624,11 +613,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ANGLETextureSharing:
     *outUnion = "angle-texture-sharing";
     break;
-  case wgpu::FeatureName::ChromiumExperimentalSubgroups:
-    *outUnion = "chromium-experimental-subgroups";
-    break;
-  case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow:
-    *outUnion = "chromium-experimental-subgroup-uniform-control-flow";
+    case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
+    *outUnion = "chromium-experimental-subgroups-matrix";
     break;
   case wgpu::FeatureName::PixelLocalStorageCoherent:
     *outUnion = "pixel-local-storage-coherent";
@@ -675,11 +661,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::R8UnormStorage:
     *outUnion = "r8unorm-storage";
     break;
-  case wgpu::FeatureName::FormatCapabilities:
-    *outUnion = "format-capabilities";
-    break;
-  case wgpu::FeatureName::DrmFormatCapabilities:
-    *outUnion = "drm-format-capabilities";
+  case wgpu::FeatureName::DawnFormatCapabilities:
+    *outUnion = "dawn-format-capabilities";
     break;
   case wgpu::FeatureName::Norm16TextureFormats:
     *outUnion = "norm16-texture-formats";
@@ -726,9 +709,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
     *outUnion = "shared-fence-vk-semaphore-opaque-fd";
     break;
-  case wgpu::FeatureName::SharedFenceVkSemaphoreSyncFD:
-    *outUnion = "shared-fence-vk-semaphore-sync-fd";
-    break;
   case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:
     *outUnion = "shared-fence-vk-semaphore-zircon-handle";
     break;