react-native-webgpu 0.8.0 → 0.8.2

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -8,195 +8,124 @@
 
 namespace rnwgpu {
 
+// Single source of truth for the wgpu::FeatureName <-> GPUFeatureName string
+// mapping. Every conversion (both directions, here and in EnumMapper, see
+// api/descriptors/Unions.h) is derived from this list so the tables cannot
+// drift apart.
+//
+// The list must cover every value of wgpu::FeatureName. Dawn adds features on
+// every milestone upgrade; FeatureNames.spec.ts diffs this list against the
+// enum in the installed webgpu_cpp.h and fails when one is missing.
+#define RNWGPU_FOR_EACH_FEATURE_NAME(V)                                        \
+  V(CoreFeaturesAndLimits, "core-features-and-limits")                         \
+  V(DepthClipControl, "depth-clip-control")                                    \
+  V(Depth32FloatStencil8, "depth32float-stencil8")                             \
+  V(TextureCompressionBC, "texture-compression-bc")                            \
+  V(TextureCompressionBCSliced3D, "texture-compression-bc-sliced-3d")          \
+  V(TextureCompressionETC2, "texture-compression-etc2")                        \
+  V(TextureCompressionASTC, "texture-compression-astc")                        \
+  V(TextureCompressionASTCSliced3D, "texture-compression-astc-sliced-3d")      \
+  V(TimestampQuery, "timestamp-query")                                         \
+  V(IndirectFirstInstance, "indirect-first-instance")                          \
+  V(ShaderF16, "shader-f16")                                                   \
+  V(RG11B10UfloatRenderable, "rg11b10ufloat-renderable")                       \
+  V(BGRA8UnormStorage, "bgra8unorm-storage")                                   \
+  V(Float32Filterable, "float32-filterable")                                   \
+  V(Float32Blendable, "float32-blendable")                                     \
+  V(ClipDistances, "clip-distances")                                           \
+  V(DualSourceBlending, "dual-source-blending")                                \
+  V(Subgroups, "subgroups")                                                    \
+  V(TextureFormatsTier1, "texture-formats-tier1")                              \
+  V(TextureFormatsTier2, "texture-formats-tier2")                              \
+  V(PrimitiveIndex, "primitive-index")                                         \
+  V(TextureComponentSwizzle, "texture-component-swizzle")                      \
+  V(SubgroupSizeControl, "subgroup-size-control")                              \
+  V(DawnInternalUsages, "dawn-internal-usages")                                \
+  V(DawnMultiPlanarFormats, "dawn-multi-planar-formats")                       \
+  V(DawnNative, "dawn-native")                                                 \
+  V(ChromiumExperimentalTimestampQueryInsidePasses,                            \
+    "chromium-experimental-timestamp-query-inside-passes")                     \
+  V(ImplicitDeviceSynchronization, "implicit-device-synchronization")          \
+  V(TransientAttachments, "transient-attachments")                             \
+  V(MSAARenderToSingleSampled, "msaa-render-to-single-sampled")                \
+  V(D3D11MultithreadProtected, "d3d11-multithread-protected")                  \
+  V(ANGLETextureSharing, "angle-texture-sharing")                              \
+  V(PixelLocalStorageCoherent, "pixel-local-storage-coherent")                 \
+  V(PixelLocalStorageNonCoherent, "pixel-local-storage-non-coherent")          \
+  V(Unorm16TextureFormats, "unorm16-texture-formats")                          \
+  V(MultiPlanarFormatExtendedUsages, "multi-planar-format-extended-usages")    \
+  V(MultiPlanarFormatP010, "multi-planar-format-p010")                         \
+  V(HostMappedPointer, "host-mapped-pointer")                                  \
+  V(MultiPlanarRenderTargets, "multi-planar-render-targets")                   \
+  V(MultiPlanarFormatNv12a, "multi-planar-format-nv12a")                       \
+  V(FramebufferFetch, "framebuffer-fetch")                                     \
+  V(BufferMapExtendedUsages, "buffer-map-extended-usages")                     \
+  V(AdapterPropertiesMemoryHeaps, "adapter-properties-memory-heaps")           \
+  V(AdapterPropertiesD3D, "adapter-properties-d3d")                            \
+  V(AdapterPropertiesVk, "adapter-properties-vk")                              \
+  V(DawnFormatCapabilities, "format-capabilities")                             \
+  V(DawnDrmFormatCapabilities, "drm-format-capabilities")                      \
+  V(MultiPlanarFormatNv16, "multi-planar-format-nv16")                         \
+  V(MultiPlanarFormatNv24, "multi-planar-format-nv24")                         \
+  V(MultiPlanarFormatP210, "multi-planar-format-p210")                         \
+  V(MultiPlanarFormatP410, "multi-planar-format-p410")                         \
+  V(SharedTextureMemoryVkDedicatedAllocation,                                  \
+    "shared-texture-memory-vk-dedicated-allocation")                           \
+  V(SharedTextureMemoryAHardwareBuffer,                                        \
+    "shared-texture-memory-ahardware-buffer")                                  \
+  V(SharedTextureMemoryDmaBuf, "shared-texture-memory-dma-buf")                \
+  V(SharedTextureMemoryOpaqueFD, "shared-texture-memory-opaque-fd")            \
+  V(SharedTextureMemoryZirconHandle, "shared-texture-memory-zircon-handle")    \
+  V(SharedTextureMemoryDXGISharedHandle,                                       \
+    "shared-texture-memory-dxgi-shared-handle")                                \
+  V(SharedTextureMemoryD3D11Texture2D,                                         \
+    "shared-texture-memory-d3d11-texture2d")                                   \
+  V(SharedTextureMemoryIOSurface, "shared-texture-memory-iosurface")           \
+  V(SharedTextureMemoryEGLImage, "shared-texture-memory-egl-image")            \
+  V(SharedFenceVkSemaphoreOpaqueFD, "shared-fence-vk-semaphore-opaque-fd")     \
+  V(SharedFenceSyncFD, "shared-fence-sync-fd")                                 \
+  V(SharedFenceVkSemaphoreZirconHandle,                                        \
+    "shared-fence-vk-semaphore-zircon-handle")                                 \
+  V(SharedFenceDXGISharedHandle, "shared-fence-dxgi-shared-handle")            \
+  V(SharedFenceMTLSharedEvent, "shared-fence-mtl-shared-event")                \
+  V(SharedBufferMemoryD3D12Resource, "shared-buffer-memory-d3d12-resource")    \
+  V(StaticSamplers, "static-samplers")                                         \
+  V(YCbCrVulkanSamplers, "ycbcr-vulkan-samplers")                              \
+  V(ShaderModuleCompilationOptions, "shader-module-compilation-options")       \
+  V(DawnLoadResolveTexture, "dawn-load-resolve-texture")                       \
+  V(DawnPartialLoadResolveTexture, "dawn-partial-load-resolve-texture")        \
+  V(MultiDrawIndirect, "multi-draw-indirect")                                  \
+  V(DawnTexelCopyBufferRowAlignment, "dawn-texel-copy-buffer-row-alignment")   \
+  V(FlexibleTextureViews, "flexible-texture-views")                            \
+  V(ChromiumExperimentalSubgroupMatrix,                                        \
+    "chromium-experimental-subgroups-matrix")                                  \
+  V(SharedFenceEGLSync, "shared-fence-egl-sync")                               \
+  V(DawnDeviceAllocatorControl, "dawn-device-allocator-control")               \
+  V(AdapterPropertiesWGPU, "adapter-properties-wgpu")                          \
+  V(SharedBufferMemoryFromWindowsHandle,                                       \
+    "shared-buffer-memory-from-windows-handle")                                \
+  V(SharedTextureMemoryD3D12Resource, "shared-texture-memory-d3d12-resource")  \
+  V(ChromiumExperimentalSamplingResourceTable,                                 \
+    "chromium-experimental-sampling-resource-table")                           \
+  V(AtomicVec2uMinMax, "atomic-vec2u-min-max")                                 \
+  V(Unorm16FormatsForExternalTexture, "unorm16-formats-for-external-texture")  \
+  V(OpaqueYCbCrAndroidForExternalTexture,                                      \
+    "opaque-ycbcr-android-for-external-texture")                               \
+  V(Unorm16Filterable, "unorm16-filterable")                                   \
+  V(RenderPassRenderArea, "render-pass-render-area")                           \
+  V(AdapterPropertiesDrm, "adapter-properties-drm")                            \
+  V(TextureCompressionUnaligned, "texture-compression-unaligned")              \
+  V(DawnAllowUndefinedLoadStoreOp, "dawn-allow-undefined-load-store-op")
+
 static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
                                  std::string *outUnion) {
   switch (inEnum) {
-  case wgpu::FeatureName::DepthClipControl:
-    *outUnion = "depth-clip-control";
-    break;
-  case wgpu::FeatureName::Depth32FloatStencil8:
-    *outUnion = "depth32float-stencil8";
-    break;
-  case wgpu::FeatureName::TimestampQuery:
-    *outUnion = "timestamp-query";
-    break;
-  case wgpu::FeatureName::TextureCompressionBC:
-    *outUnion = "texture-compression-bc";
-    break;
-  case wgpu::FeatureName::TextureCompressionETC2:
-    *outUnion = "texture-compression-etc2";
-    break;
-  case wgpu::FeatureName::TextureCompressionASTC:
-    *outUnion = "texture-compression-astc";
-    break;
-  case wgpu::FeatureName::IndirectFirstInstance:
-    *outUnion = "indirect-first-instance";
-    break;
-  case wgpu::FeatureName::ShaderF16:
-    *outUnion = "shader-f16";
-    break;
-  case wgpu::FeatureName::RG11B10UfloatRenderable:
-    *outUnion = "rg11b10ufloat-renderable";
-    break;
-  case wgpu::FeatureName::BGRA8UnormStorage:
-    *outUnion = "bgra8unorm-storage";
-    break;
-  case wgpu::FeatureName::Float32Filterable:
-    *outUnion = "float32-filterable";
-    break;
-  case wgpu::FeatureName::Subgroups:
-    *outUnion = "subgroups";
-    break;
-  case wgpu::FeatureName::DawnInternalUsages:
-    *outUnion = "dawn-internal-usages";
-    break;
-  case wgpu::FeatureName::DawnMultiPlanarFormats:
-    *outUnion = "dawn-multi-planar-formats";
-    break;
-  case wgpu::FeatureName::DawnNative:
-    *outUnion = "dawn-native";
-    break;
-  case wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses:
-    *outUnion = "chromium-experimental-timestamp-query-inside-passes";
-    break;
-  case wgpu::FeatureName::ImplicitDeviceSynchronization:
-    *outUnion = "implicit-device-synchronization";
-    break;
-  case wgpu::FeatureName::TransientAttachments:
-    *outUnion = "transient-attachments";
-    break;
-  case wgpu::FeatureName::MSAARenderToSingleSampled:
-    *outUnion = "msaa-render-to-single-sampled";
-    break;
-  case wgpu::FeatureName::DualSourceBlending:
-    *outUnion = "dual-source-blending";
-    break;
-  case wgpu::FeatureName::D3D11MultithreadProtected:
-    *outUnion = "d3d11-multithread-protected";
-    break;
-  case wgpu::FeatureName::ANGLETextureSharing:
-    *outUnion = "angle-texture-sharing";
-    break;
-  case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
-    *outUnion = "chromium-experimental-subgroups-matrix";
-    break;
-  case wgpu::FeatureName::PixelLocalStorageCoherent:
-    *outUnion = "pixel-local-storage-coherent";
-    break;
-  case wgpu::FeatureName::PixelLocalStorageNonCoherent:
-    *outUnion = "pixel-local-storage-non-coherent";
-    break;
-  case wgpu::FeatureName::Unorm16TextureFormats:
-    *outUnion = "unorm16-texture-formats";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatExtendedUsages:
-    *outUnion = "multi-planar-format-extended-usages";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatP010:
-    *outUnion = "multi-planar-format-p010";
-    break;
-  case wgpu::FeatureName::HostMappedPointer:
-    *outUnion = "host-mapped-pointer";
-    break;
-  case wgpu::FeatureName::MultiPlanarRenderTargets:
-    *outUnion = "multi-planar-render-targets";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatNv12a:
-    *outUnion = "multi-planar-format-nv12a";
-    break;
-  case wgpu::FeatureName::FramebufferFetch:
-    *outUnion = "framebuffer-fetch";
-    break;
-  case wgpu::FeatureName::BufferMapExtendedUsages:
-    *outUnion = "buffer-map-extended-usages";
-    break;
-  case wgpu::FeatureName::AdapterPropertiesMemoryHeaps:
-    *outUnion = "adapter-properties-memory-heaps";
-    break;
-  case wgpu::FeatureName::AdapterPropertiesD3D:
-    *outUnion = "adapter-properties-d3d";
-    break;
-  case wgpu::FeatureName::AdapterPropertiesVk:
-    *outUnion = "adapter-properties-vk";
-    break;
-  case wgpu::FeatureName::DawnFormatCapabilities:
-    *outUnion = "format-capabilities";
-    break;
-  case wgpu::FeatureName::DawnDrmFormatCapabilities:
-    *outUnion = "drm-format-capabilities";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatNv16:
-    *outUnion = "multi-planar-format-nv16";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatNv24:
-    *outUnion = "multi-planar-format-nv24";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatP210:
-    *outUnion = "multi-planar-format-p210";
-    break;
-  case wgpu::FeatureName::MultiPlanarFormatP410:
-    *outUnion = "multi-planar-format-p410";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryVkDedicatedAllocation:
-    *outUnion = "shared-texture-memory-vk-dedicated-allocation";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer:
-    *outUnion = "shared-texture-memory-ahardware-buffer";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryDmaBuf:
-    *outUnion = "shared-texture-memory-dma-buf";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryOpaqueFD:
-    *outUnion = "shared-texture-memory-opaque-fd";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryZirconHandle:
-    *outUnion = "shared-texture-memory-zircon-handle";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryDXGISharedHandle:
-    *outUnion = "shared-texture-memory-dxgi-shared-handle";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryD3D11Texture2D:
-    *outUnion = "shared-texture-memory-d3d11-texture2d";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryIOSurface:
-    *outUnion = "shared-texture-memory-iosurface";
-    break;
-  case wgpu::FeatureName::SharedTextureMemoryEGLImage:
-    *outUnion = "shared-texture-memory-egl-image";
-    break;
-  case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD:
-    *outUnion = "shared-fence-vk-semaphore-opaque-fd";
-    break;
-  case wgpu::FeatureName::SharedFenceSyncFD:
-    *outUnion = "shared-fence-sync-fd";
-    break;
-  case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle:
-    *outUnion = "shared-fence-vk-semaphore-zircon-handle";
-    break;
-  case wgpu::FeatureName::SharedFenceDXGISharedHandle:
-    *outUnion = "shared-fence-dxgi-shared-handle";
-    break;
-  case wgpu::FeatureName::SharedFenceMTLSharedEvent:
-    *outUnion = "shared-fence-mtl-shared-event";
-    break;
-  case wgpu::FeatureName::SharedBufferMemoryD3D12Resource:
-    *outUnion = "shared-buffer-memory-d3d12-resource";
-    break;
-  case wgpu::FeatureName::StaticSamplers:
-    *outUnion = "static-samplers";
-    break;
-  case wgpu::FeatureName::YCbCrVulkanSamplers:
-    *outUnion = "ycbcr-vulkan-samplers";
-    break;
-  case wgpu::FeatureName::OpaqueYCbCrAndroidForExternalTexture:
-    *outUnion = "opaque-ycbcr-android-for-external-texture";
-    break;
-  case wgpu::FeatureName::ShaderModuleCompilationOptions:
-    *outUnion = "shader-module-compilation-options";
-    break;
-  case wgpu::FeatureName::DawnLoadResolveTexture:
-    *outUnion = "dawn-load-resolve-texture";
+#define RNWGPU_FEATURE_NAME_CASE(Enum, Name)                                   \
+  case wgpu::FeatureName::Enum:                                                \
+    *outUnion = Name;                                                          \
     break;
+    RNWGPU_FOR_EACH_FEATURE_NAME(RNWGPU_FEATURE_NAME_CASE)
+#undef RNWGPU_FEATURE_NAME_CASE
   default:
     fprintf(stderr, "Unknown feature name %d\n", static_cast<int>(inEnum));
     *outUnion = "";

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -128,6 +128,30 @@ void GPUQueue::copyExternalImageToTexture(
     throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
   }
 
+  const auto origin = source->origin.value_or(nullptr);
+  // GPUOrigin2D coordinates are [EnforceRange] unsigned long: negative,
+  // NaN, or out-of-range doubles must be rejected here because casting
+  // them to an unsigned integer is undefined behavior.
+  constexpr double kMaxOrigin =
+      static_cast<double>(std::numeric_limits<uint32_t>::max());
+  if (origin && (!(origin->x >= 0) || !(origin->y >= 0) ||
+                 origin->x > kMaxOrigin || origin->y > kMaxOrigin)) {
+    throw std::runtime_error(
+        "The source origin must be a non-negative integer coordinate.");
+  }
+  const size_t sourceOriginX =
+      origin ? static_cast<size_t>(origin->x) : 0;
+  const size_t sourceOriginY =
+      origin ? static_cast<size_t>(origin->y) : 0;
+  if (sourceOriginX > source->source->getWidth() ||
+      sz.width > source->source->getWidth() - sourceOriginX ||
+      sourceOriginY > source->source->getHeight() ||
+      sz.height > source->source->getHeight() - sourceOriginY ||
+      sz.depthOrArrayLayers > 1) {
+    throw std::runtime_error(
+        "The source copy region is outside the ImageBitmap.");
+  }
+
   const bool flipY = source->flipY.value_or(false);
   // premultipliedAlpha defaults to false per the WebGPU spec: an untagged
   // destination expects straight alpha. Convert only when the ImageBitmap's
@@ -138,28 +162,30 @@ void GPUQueue::copyExternalImageToTexture(
   const bool needsAlphaConversion =
       bytesPerPixel == 4 && sourcePremultiplied != destinationPremultiplied;
 
-  if (flipY || needsAlphaConversion) {
-    uint32_t rowSize = bytesPerPixel * source->source->getWidth();
-    uint32_t totalSize = source->source->getSize();
+  if (sourceOriginX != 0 || sourceOriginY != 0 || flipY ||
+      needsAlphaConversion) {
+    uint32_t sourceRowSize = bytesPerPixel * source->source->getWidth();
+    uint32_t rowSize = bytesPerPixel * sz.width;
+    uint32_t totalSize = rowSize * sz.height;
 
-    // Stage a mutable copy so flipping and/or alpha conversion never touch the
-    // ImageBitmap's backing store.
+    // Stage only the selected subregion so transformations never touch the
+    // ImageBitmap's backing store or pixels outside the requested copy.
     std::vector<uint8_t> staged(totalSize);
     const uint8_t *src =
         static_cast<const uint8_t *>(source->source->getData());
-    if (flipY) {
-      for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
-        std::memcpy(staged.data() +
-                        (source->source->getHeight() - 1 - row) * rowSize,
-                    src + row * rowSize, rowSize);
-      }
-    } else {
-      std::memcpy(staged.data(), src, totalSize);
+    for (uint32_t row = 0; row < sz.height; ++row) {
+      const uint32_t sourceRow =
+          sourceOriginY + (flipY ? sz.height - 1 - row : row);
+      const uint32_t sourceOffset =
+          sourceRow * sourceRowSize + sourceOriginX * bytesPerPixel;
+      std::memcpy(staged.data() + row * rowSize, src + sourceOffset, rowSize);
     }
     if (needsAlphaConversion) {
       convertAlpha(staged.data(), totalSize, sourcePremultiplied,
                    destinationPremultiplied);
     }
+    layout.bytesPerRow = rowSize;
+    layout.rowsPerImage = sz.height;
     _instance.WriteTexture(&dst, staged.data(), totalSize, &layout, &sz);
   } else {
     _instance.WriteTexture(&dst, source->source->getData(),