From 9f852fac68ce1c32610ef003387c6ff4193b6f02 Mon Sep 17 00:00:00 2001 From: William Candillon Date: Sun, 1 Jun 2025 14:54:29 +0200 Subject: [PATCH 1/8] :wrench: --- .../scripts/build/apple.toolchain.cmake | 47 +++++++++++++++---- 1 file changed, 39 insertions(+), 8 deletions(-) diff --git a/packages/webgpu/scripts/build/apple.toolchain.cmake b/packages/webgpu/scripts/build/apple.toolchain.cmake index d4997d266..cfcac8c25 100644 --- a/packages/webgpu/scripts/build/apple.toolchain.cmake +++ b/packages/webgpu/scripts/build/apple.toolchain.cmake @@ -74,6 +74,7 @@ # WATCHOSCOMBINED = Build for armv7k arm64_32 x86_64 watchOS + watchOS Simulator. Combined into FAT STATIC lib (only supported on 3.14+ of CMake with "-G Xcode" argument in combination with the "cmake --install" CMake build step) # SIMULATOR_WATCHOS = Build for x86_64 for watchOS Simulator. # SIMULATORARM64_WATCHOS = Build for arm64 for watchOS Simulator. +# SIMULATOR_WATCHOSCOMBINED = Build for arm64 x86_64 for watchOS Simulator. Combined into FAT STATIC lib (supported on 3.14+ of CMakewith "-G Xcode" argument ONLY) # MAC = Build for x86_64 macOS. # MAC_ARM64 = Build for Apple Silicon macOS. # MAC_UNIVERSAL = Combined build for x86_64 and Apple Silicon on macOS. @@ -166,7 +167,7 @@ set(ENV{_IOS_TOOLCHAIN_HAS_RUN} true) list(APPEND _supported_platforms "OS" "OS64" "OS64COMBINED" "SIMULATOR" "SIMULATOR64" "SIMULATORARM64" "SIMULATOR64COMBINED" "TVOS" "TVOSCOMBINED" "SIMULATOR_TVOS" "SIMULATORARM64_TVOS" - "WATCHOS" "WATCHOSCOMBINED" "SIMULATOR_WATCHOS" "SIMULATORARM64_WATCHOS" + "WATCHOS" "WATCHOSCOMBINED" "SIMULATOR_WATCHOS" "SIMULATORARM64_WATCHOS" "SIMULATOR_WATCHOSCOMBINED" "MAC" "MAC_ARM64" "MAC_UNIVERSAL" "VISIONOS" "SIMULATOR_VISIONOS" "VISIONOSCOMBINED" "MAC_CATALYST" "MAC_CATALYST_ARM64" "MAC_CATALYST_UNIVERSAL") @@ -461,12 +462,12 @@ elseif(PLATFORM_INT STREQUAL "WATCHOSCOMBINED") if(MODERN_CMAKE) if(NOT ARCHS) if (XCODE_VERSION_INT VERSION_GREATER 10.0) - set(ARCHS armv7k arm64_32 i386) - set(APPLE_TARGET_TRIPLE_INT arm64_32-i386-apple-watchos${DEPLOYMENT_TARGET}) + set(ARCHS armv7k arm64_32 x86_64) + set(APPLE_TARGET_TRIPLE_INT arm64_32-x86_64-apple-watchos${DEPLOYMENT_TARGET}) set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchos*] "armv7k arm64_32") - set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchsimulator*] "i386") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchsimulator*] "x86_64") set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchos*] "armv7k arm64_32") - set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchsimulator*] "i386") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchsimulator*] "x86_64") else() set(ARCHS armv7k i386) set(APPLE_TARGET_TRIPLE_INT arm-i386-apple-watchos${DEPLOYMENT_TARGET}) @@ -484,8 +485,13 @@ elseif(PLATFORM_INT STREQUAL "WATCHOSCOMBINED") elseif(PLATFORM_INT STREQUAL "SIMULATOR_WATCHOS") set(SDK_NAME watchsimulator) if(NOT ARCHS) - set(ARCHS i386) - set(APPLE_TARGET_TRIPLE_INT i386-apple-watchos${DEPLOYMENT_TARGET}-simulator) + if (XCODE_VERSION_INT VERSION_GREATER 10.0) + set(ARCHS x86_64) + set(APPLE_TARGET_TRIPLE_INT x86_64-apple-watchos${DEPLOYMENT_TARGET}-simulator) + else() + set(ARCHS i386) + set(APPLE_TARGET_TRIPLE_INT i386-apple-watchos${DEPLOYMENT_TARGET}-simulator) + endif() else() set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-watchos${DEPLOYMENT_TARGET}-simulator) endif() @@ -497,6 +503,31 @@ elseif(PLATFORM_INT STREQUAL "SIMULATORARM64_WATCHOS") else() set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-watchos${DEPLOYMENT_TARGET}-simulator) endif() +elseif(PLATFORM_INT STREQUAL "SIMULATOR_WATCHOSCOMBINED") + set(SDK_NAME watchsimulator) + if(MODERN_CMAKE) + if(NOT ARCHS) + if (XCODE_VERSION_INT VERSION_GREATER 12.0) + set(ARCHS arm64 x86_64) + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchos*] "") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchsimulator*] "arm64 x86_64") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchos*] "") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchsimulator*] "arm64 x86_64") + set(APPLE_TARGET_TRIPLE_INT arm64_x86_64-apple-watchos${DEPLOYMENT_TARGET}-simulator) + else() + set(ARCHS arm64 i386) + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchos*] "") + set(CMAKE_XCODE_ATTRIBUTE_ARCHS[sdk=watchsimulator*] "i386") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchos*] "") + set(CMAKE_XCODE_ATTRIBUTE_VALID_ARCHS[sdk=watchsimulator*] "i386") + set(APPLE_TARGET_TRIPLE_INT arm64_i386-apple-watchos${DEPLOYMENT_TARGET}-simulator) + endif() + else() + set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-watchos${DEPLOYMENT_TARGET}-simulator) + endif() + else() + message(FATAL_ERROR "Please make sure that you are running CMake 3.14+ to make the SIMULATOR_WATCHOSCOMBINED setting work") + endif() elseif(PLATFORM_INT STREQUAL "SIMULATOR_VISIONOS") set(SDK_NAME xrsimulator) if(NOT ARCHS) @@ -1142,4 +1173,4 @@ macro(find_host_package) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH) set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH) set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE BOTH) -endmacro(find_host_package) +endmacro(find_host_package) \ No newline at end of file From f04b71846a249797394bc026b57059b24d93fa1c Mon Sep 17 00:00:00 2001 From: William Candillon Date: Sun, 1 Jun 2025 15:40:54 +0200 Subject: [PATCH 2/8] Update WebGPU build script --- .../scripts/build/apple.toolchain.cmake | 5 ++-- packages/webgpu/scripts/build/dawn.ts | 4 ++- .../webgpu/scripts/build/static_build.patch | 27 ++++++++++++++++++- 3 files changed, 32 insertions(+), 4 deletions(-) diff --git a/packages/webgpu/scripts/build/apple.toolchain.cmake b/packages/webgpu/scripts/build/apple.toolchain.cmake index cfcac8c25..987a8c0cc 100644 --- a/packages/webgpu/scripts/build/apple.toolchain.cmake +++ b/packages/webgpu/scripts/build/apple.toolchain.cmake @@ -585,8 +585,9 @@ elseif(PLATFORM_INT STREQUAL "MAC_UNIVERSAL") if(NOT ARCHS) set(ARCHS "x86_64;arm64") endif() - string(REPLACE ";" "-" ARCHS_SPLIT "${ARCHS}") - set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-macosx${DEPLOYMENT_TARGET}) + # For universal builds, don't set target triple - let CMake handle it + # string(REPLACE ";" "-" ARCHS_SPLIT "${ARCHS}") + # set(APPLE_TARGET_TRIPLE_INT ${ARCHS_SPLIT}-apple-macosx${DEPLOYMENT_TARGET}) elseif(PLATFORM_INT STREQUAL "MAC_CATALYST_UNIVERSAL") set(SDK_NAME macosx) if(NOT ARCHS) diff --git a/packages/webgpu/scripts/build/dawn.ts b/packages/webgpu/scripts/build/dawn.ts index 7b1813a59..4d3f0b31d 100644 --- a/packages/webgpu/scripts/build/dawn.ts +++ b/packages/webgpu/scripts/build/dawn.ts @@ -96,7 +96,9 @@ const apple = { (async () => { process.chdir("../.."); process.chdir("externals/dawn"); - $("git reset --hard HEAD"); + $( + "git reset --hard HEAD && git submodule foreach --recursive git reset --hard HEAD && git submodule update --init --recursive", + ); $(`git apply ${__dirname}/static_build.patch`); process.chdir("../.."); console.log("Copy headers"); diff --git a/packages/webgpu/scripts/build/static_build.patch b/packages/webgpu/scripts/build/static_build.patch index 122165b62..71ebbeb9b 100644 --- a/packages/webgpu/scripts/build/static_build.patch +++ b/packages/webgpu/scripts/build/static_build.patch @@ -1,5 +1,5 @@ diff --git a/src/cmake/BundleLibraries.cmake b/src/cmake/BundleLibraries.cmake -index 046a6af10d..5a63ac3d6d 100644 +index 046a6af10d..ee272710fd 100644 --- a/src/cmake/BundleLibraries.cmake +++ b/src/cmake/BundleLibraries.cmake @@ -66,8 +66,11 @@ function(bundle_libraries output_target) @@ -16,3 +16,28 @@ index 046a6af10d..5a63ac3d6d 100644 add_dependencies(${output_target} ${ARGN}) endfunction() +Submodule third_party/abseil-cpp contains modified content +diff --git a/third_party/abseil-cpp/absl/copts/AbseilConfigureCopts.cmake b/third_party/abseil-cpp/absl/copts/AbseilConfigureCopts.cmake +index 3f737c8..9b8bb4b 100644 +--- a/third_party/abseil-cpp/absl/copts/AbseilConfigureCopts.cmake ++++ b/third_party/abseil-cpp/absl/copts/AbseilConfigureCopts.cmake +@@ -11,6 +11,11 @@ else() + endif() + + if(APPLE AND CMAKE_CXX_COMPILER_ID MATCHES [[Clang]]) ++ # Fix for iOS/visionOS ARM64 builds - skip x86_64 flags when building for ARM64 only ++ if((CMAKE_SYSTEM_NAME STREQUAL "iOS" OR CMAKE_SYSTEM_NAME STREQUAL "visionOS") AND CMAKE_OSX_ARCHITECTURES MATCHES "arm64" AND NOT CMAKE_OSX_ARCHITECTURES MATCHES "x86_64") ++ set(ABSL_RANDOM_RANDEN_COPTS "${ABSL_RANDOM_HWAES_ARM64_FLAGS}") ++ list(APPEND ABSL_RANDOM_RANDEN_COPTS "-Wno-unused-command-line-argument") ++ else() + # Some CMake targets (not known at the moment of processing) could be set to + # compile for multiple architectures as specified by the OSX_ARCHITECTURES + # property, which is target-specific. We should neither inspect nor rely on +@@ -52,6 +57,7 @@ if(APPLE AND CMAKE_CXX_COMPILER_ID MATCHES [[Clang]]) + if(ABSL_RANDOM_RANDEN_COPTS AND NOT ABSL_RANDOM_RANDEN_COPTS_WARNING) + list(APPEND ABSL_RANDOM_RANDEN_COPTS "-Wno-unused-command-line-argument") + endif() ++ endif() # End iOS ARM64 fix + elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64") + if (MSVC) + set(ABSL_RANDOM_RANDEN_COPTS "${ABSL_RANDOM_HWAES_MSVC_X64_FLAGS}") From 4b126cc68a0763201473ace1f4b45cd84acf486c Mon Sep 17 00:00:00 2001 From: William Candillon Date: Sun, 1 Jun 2025 15:49:53 +0200 Subject: [PATCH 3/8] :wrench: --- packages/webgpu/scripts/build/dawn.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/webgpu/scripts/build/dawn.ts b/packages/webgpu/scripts/build/dawn.ts index 4d3f0b31d..617cf0a5a 100644 --- a/packages/webgpu/scripts/build/dawn.ts +++ b/packages/webgpu/scripts/build/dawn.ts @@ -97,7 +97,7 @@ const apple = { process.chdir("../.."); process.chdir("externals/dawn"); $( - "git reset --hard HEAD && git submodule foreach --recursive git reset --hard HEAD && git submodule update --init --recursive", + "git reset --hard HEAD && cd third_party/abseil-cpp && git reset --hard HEAD && cd ../..", ); $(`git apply ${__dirname}/static_build.patch`); process.chdir("../.."); From d290b33b1f3286b1aaf1f7376677f1aa0825b372 Mon Sep 17 00:00:00 2001 From: William Candillon Date: Sun, 1 Jun 2025 17:56:45 +0200 Subject: [PATCH 4/8] :wrench: --- .gitmodules | 2 +- externals/dawn | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitmodules b/.gitmodules index 80f487149..e44484a5c 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,4 +1,4 @@ [submodule "externals/dawn"] path = externals/dawn url = https://dawn.googlesource.com/dawn - branch = chromium/6793 + branch = chromium/7213 diff --git a/externals/dawn b/externals/dawn index a690fe423..56a4aec00 160000 --- a/externals/dawn +++ b/externals/dawn @@ -1 +1 @@ -Subproject commit a690fe42392c8b8043a37fbfbbb69d0f5a02c814 +Subproject commit 56a4aec006181ed29853e5cd2bdd6a237798c958 From 447a83a67335bb7172564e731be0f0ad17796eb5 Mon Sep 17 00:00:00 2001 From: William Candillon Date: Sun, 1 Jun 2025 18:09:11 +0200 Subject: [PATCH 5/8] :arrow_up: --- packages/webgpu/cpp/dawn_logging.cpp | 122 ++++++++++++++++++ packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h | 4 +- packages/webgpu/cpp/rnwgpu/api/Convertors.h | 80 ++++++------ packages/webgpu/cpp/rnwgpu/api/GPU.cpp | 83 ++++++------ packages/webgpu/cpp/rnwgpu/api/GPU.h | 8 +- packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp | 89 +++++++------ packages/webgpu/cpp/rnwgpu/api/GPUBuffer.cpp | 40 +++--- .../cpp/rnwgpu/api/GPUCanvasContext.cpp | 9 +- .../cpp/rnwgpu/api/GPUCommandEncoder.cpp | 12 +- .../cpp/rnwgpu/api/GPUCompilationInfo.h | 13 +- packages/webgpu/cpp/rnwgpu/api/GPUDevice.cpp | 17 +-- packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h | 18 ++- packages/webgpu/cpp/rnwgpu/api/GPUQueue.cpp | 8 +- .../webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp | 5 +- .../cpp/rnwgpu/api/GPUSupportedLimits.cpp | 67 +++++----- .../cpp/rnwgpu/api/GPUSupportedLimits.h | 14 +- .../cpp/rnwgpu/api/descriptors/Unions.h | 30 ++--- 17 files changed, 366 insertions(+), 253 deletions(-) create mode 100644 packages/webgpu/cpp/dawn_logging.cpp diff --git a/packages/webgpu/cpp/dawn_logging.cpp b/packages/webgpu/cpp/dawn_logging.cpp new file mode 100644 index 000000000..a7aa3420d --- /dev/null +++ b/packages/webgpu/cpp/dawn_logging.cpp @@ -0,0 +1,122 @@ +#include +#include + +#ifdef __ANDROID__ +#include +#elif defined(__APPLE__) +#include +#endif + +namespace dawn { + +enum class LogSeverity { + Debug, + Info, + Warning, + Error, +}; + +// Forward declare to match Dawn's exact interface +class LogMessage { +public: + explicit LogMessage(LogSeverity severity); + ~LogMessage(); + + LogMessage(LogMessage&& other); + LogMessage& operator=(LogMessage&& other); + + template + LogMessage& operator<<(T&& value) { + mStream << value; + return *this; + } + +private: + LogMessage(const LogMessage& other) = delete; + LogMessage& operator=(const LogMessage& other) = delete; + + LogSeverity mSeverity; + std::ostringstream mStream; +}; + +// Implementation of LogMessage methods +LogMessage::LogMessage(LogSeverity severity) : mSeverity(severity) {} + +LogMessage::LogMessage(LogMessage&& other) + : mSeverity(other.mSeverity), mStream(std::move(other.mStream)) {} + +LogMessage& LogMessage::operator=(LogMessage&& other) { + if (this != &other) { + mSeverity = other.mSeverity; + mStream = std::move(other.mStream); + } + return *this; +} + +LogMessage::~LogMessage() { + std::string fullMessage = mStream.str(); + + if (fullMessage.empty()) { + return; + } + + const char* severityName; + switch (mSeverity) { + case LogSeverity::Debug: severityName = "Debug"; break; + case LogSeverity::Info: severityName = "Info"; break; + case LogSeverity::Warning: severityName = "Warning"; break; + case LogSeverity::Error: severityName = "Error"; break; + default: severityName = "Unknown"; break; + } + +#ifdef __ANDROID__ + int androidPriority; + switch (mSeverity) { + case LogSeverity::Debug: androidPriority = ANDROID_LOG_DEBUG; break; + case LogSeverity::Info: androidPriority = ANDROID_LOG_INFO; break; + case LogSeverity::Warning: androidPriority = ANDROID_LOG_WARN; break; + case LogSeverity::Error: androidPriority = ANDROID_LOG_ERROR; break; + default: androidPriority = ANDROID_LOG_ERROR; break; + } + __android_log_print(androidPriority, "ReactNativeWebGPU", "%s: %s", severityName, fullMessage.c_str()); +#elif defined(__APPLE__) + os_log_type_t logType; + switch (mSeverity) { + case LogSeverity::Debug: logType = OS_LOG_TYPE_DEBUG; break; + case LogSeverity::Info: logType = OS_LOG_TYPE_INFO; break; + case LogSeverity::Warning: logType = OS_LOG_TYPE_DEFAULT; break; + case LogSeverity::Error: logType = OS_LOG_TYPE_ERROR; break; + default: logType = OS_LOG_TYPE_ERROR; break; + } + os_log_with_type(OS_LOG_DEFAULT, logType, "[ReactNativeWebGPU] %s: %s", severityName, fullMessage.c_str()); +#else + FILE* outputStream = (mSeverity == LogSeverity::Warning || mSeverity == LogSeverity::Error) ? stderr : stdout; + fprintf(outputStream, "[ReactNativeWebGPU] %s: %s\n", severityName, fullMessage.c_str()); + fflush(outputStream); +#endif +} + +// Factory functions +LogMessage DebugLog() { + return LogMessage(LogSeverity::Debug); +} + +LogMessage InfoLog() { + return LogMessage(LogSeverity::Info); +} + +LogMessage WarningLog() { + return LogMessage(LogSeverity::Warning); +} + +LogMessage ErrorLog() { + return LogMessage(LogSeverity::Error); +} + +LogMessage DebugLog(const char* file, const char* function, int line) { + LogMessage message = DebugLog(); + message << file << ":" << line << "(" << function << ")"; + return message; +} + +} // namespace dawn \ No newline at end of file diff --git a/packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h b/packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h index 7ec417e64..8ab94678a 100644 --- a/packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h +++ b/packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h @@ -83,10 +83,10 @@ class SurfaceInfo { auto device = config.device; wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc); - wgpu::ImageCopyTexture sourceTexture = {}; + wgpu::TexelCopyTextureInfo sourceTexture = {}; sourceTexture.texture = texture; - wgpu::ImageCopyTexture destinationTexture = {}; + wgpu::TexelCopyTextureInfo destinationTexture = {}; wgpu::SurfaceTexture surfaceTexture; surface.GetCurrentTexture(&surfaceTexture); destinationTexture.texture = surfaceTexture.texture; diff --git a/packages/webgpu/cpp/rnwgpu/api/Convertors.h b/packages/webgpu/cpp/rnwgpu/api/Convertors.h index 4e88e20fd..0916d9fdc 100644 --- a/packages/webgpu/cpp/rnwgpu/api/Convertors.h +++ b/packages/webgpu/cpp/rnwgpu/api/Convertors.h @@ -309,7 +309,7 @@ class Convertor { Convert(out.label, in.label); } - [[nodiscard]] bool Convert(wgpu::ComputePassTimestampWrites &out, + [[nodiscard]] bool Convert(wgpu::PassTimestampWrites &out, const GPUComputePassTimestampWrites &in) { return Convert(out.querySet, in.querySet) && Convert(out.beginningOfPassWriteIndex, @@ -348,74 +348,70 @@ class Convertor { if (in.requiredLimits.has_value()) { const auto &limits = in.requiredLimits.value(); - auto *requiredLimits = Allocate(); + auto *requiredLimits = Allocate(); for (const auto &[key, value] : limits) { if (key == "maxTextureDimension1D") { - requiredLimits->limits.maxTextureDimension1D = value; + requiredLimits->maxTextureDimension1D = value; } else if (key == "maxTextureDimension2D") { - requiredLimits->limits.maxTextureDimension2D = value; + requiredLimits->maxTextureDimension2D = value; } else if (key == "maxTextureDimension3D") { - requiredLimits->limits.maxTextureDimension3D = value; + requiredLimits->maxTextureDimension3D = value; } else if (key == "maxTextureArrayLayers") { - requiredLimits->limits.maxTextureArrayLayers = value; + requiredLimits->maxTextureArrayLayers = value; } else if (key == "maxBindGroups") { - requiredLimits->limits.maxBindGroups = value; + requiredLimits->maxBindGroups = value; } else if (key == "maxBindGroupsPlusVertexBuffers") { - requiredLimits->limits.maxBindGroupsPlusVertexBuffers = value; + requiredLimits->maxBindGroupsPlusVertexBuffers = value; } else if (key == "maxBindingsPerBindGroup") { - requiredLimits->limits.maxBindingsPerBindGroup = value; + requiredLimits->maxBindingsPerBindGroup = value; } else if (key == "maxDynamicUniformBuffersPerPipelineLayout") { - requiredLimits->limits.maxDynamicUniformBuffersPerPipelineLayout = - value; + requiredLimits->maxDynamicUniformBuffersPerPipelineLayout = value; } else if (key == "maxDynamicStorageBuffersPerPipelineLayout") { - requiredLimits->limits.maxDynamicStorageBuffersPerPipelineLayout = - value; + requiredLimits->maxDynamicStorageBuffersPerPipelineLayout = value; } else if (key == "maxSampledTexturesPerShaderStage") { - requiredLimits->limits.maxSampledTexturesPerShaderStage = value; + requiredLimits->maxSampledTexturesPerShaderStage = value; } else if (key == "maxSamplersPerShaderStage") { - requiredLimits->limits.maxSamplersPerShaderStage = value; + requiredLimits->maxSamplersPerShaderStage = value; } else if (key == "maxStorageBuffersPerShaderStage") { - requiredLimits->limits.maxStorageBuffersPerShaderStage = value; + requiredLimits->maxStorageBuffersPerShaderStage = value; } else if (key == "maxStorageTexturesPerShaderStage") { - requiredLimits->limits.maxStorageTexturesPerShaderStage = value; + requiredLimits->maxStorageTexturesPerShaderStage = value; } else if (key == "maxUniformBuffersPerShaderStage") { - requiredLimits->limits.maxUniformBuffersPerShaderStage = value; + requiredLimits->maxUniformBuffersPerShaderStage = value; } else if (key == "maxUniformBufferBindingSize") { - requiredLimits->limits.maxUniformBufferBindingSize = value; + requiredLimits->maxUniformBufferBindingSize = value; } else if (key == "maxStorageBufferBindingSize") { - requiredLimits->limits.maxStorageBufferBindingSize = value; + requiredLimits->maxStorageBufferBindingSize = value; } else if (key == "minUniformBufferOffsetAlignment") { - requiredLimits->limits.minUniformBufferOffsetAlignment = value; + requiredLimits->minUniformBufferOffsetAlignment = value; } else if (key == "minStorageBufferOffsetAlignment") { - requiredLimits->limits.minStorageBufferOffsetAlignment = value; + requiredLimits->minStorageBufferOffsetAlignment = value; } else if (key == "maxVertexBuffers") { - requiredLimits->limits.maxVertexBuffers = value; + requiredLimits->maxVertexBuffers = value; } else if (key == "maxBufferSize") { - requiredLimits->limits.maxBufferSize = value; + requiredLimits->maxBufferSize = value; } else if (key == "maxVertexAttributes") { - requiredLimits->limits.maxVertexAttributes = value; + requiredLimits->maxVertexAttributes = value; } else if (key == "maxVertexBufferArrayStride") { - requiredLimits->limits.maxVertexBufferArrayStride = value; - } else if (key == "maxInterStageShaderComponents") { - requiredLimits->limits.maxInterStageShaderComponents = value; + requiredLimits->maxVertexBufferArrayStride = value; } else if (key == "maxInterStageShaderVariables") { - requiredLimits->limits.maxInterStageShaderVariables = value; + requiredLimits->maxInterStageShaderVariables = value; } else if (key == "maxColorAttachments") { - requiredLimits->limits.maxColorAttachments = value; + requiredLimits->maxColorAttachments = value; } else if (key == "maxColorAttachmentBytesPerSample") { - requiredLimits->limits.maxColorAttachmentBytesPerSample = value; + requiredLimits->maxColorAttachmentBytesPerSample = value; } else if (key == "maxComputeWorkgroupStorageSize") { - requiredLimits->limits.maxComputeWorkgroupStorageSize = value; + requiredLimits->maxComputeWorkgroupStorageSize = value; } else if (key == "maxComputeInvocationsPerWorkgroup") { - requiredLimits->limits.maxComputeInvocationsPerWorkgroup = value; + requiredLimits->maxComputeInvocationsPerWorkgroup = value; } else if (key == "maxComputeWorkgroupSizeX") { - requiredLimits->limits.maxComputeWorkgroupSizeX = value; + requiredLimits->maxComputeWorkgroupSizeX = value; } else if (key == "maxComputeWorkgroupSizeY") { - requiredLimits->limits.maxComputeWorkgroupSizeY = value; + requiredLimits->maxComputeWorkgroupSizeY = value; } else if (key == "maxComputeWorkgroupSizeZ") { - requiredLimits->limits.maxComputeWorkgroupSizeZ = value; + requiredLimits->maxComputeWorkgroupSizeZ = value; } else if (key == "maxComputeWorkgroupsPerDimension") { - requiredLimits->limits.maxComputeWorkgroupsPerDimension = value; + requiredLimits->maxComputeWorkgroupsPerDimension = value; } } out.requiredLimits = requiredLimits; @@ -452,7 +448,7 @@ class Convertor { Convert(out.constants, out.constantCount, in.constants); } - [[nodiscard]] bool Convert(wgpu::ImageCopyBuffer &out, + [[nodiscard]] bool Convert(wgpu::TexelCopyBufferInfo &out, const GPUImageCopyBuffer &in) { out = {}; out.buffer = in.buffer->get(); @@ -461,13 +457,13 @@ class Convertor { Convert(out.layout.rowsPerImage, in.rowsPerImage); } - [[nodiscard]] bool Convert(wgpu::ImageCopyTexture &out, + [[nodiscard]] bool Convert(wgpu::TexelCopyTextureInfo &out, const GPUImageCopyTexture &in) { return Convert(out.origin, in.origin) && Convert(out.texture, in.texture) && Convert(out.mipLevel, in.mipLevel) && Convert(out.aspect, in.aspect); } - [[nodiscard]] bool Convert(wgpu::TextureDataLayout &out, + [[nodiscard]] bool Convert(wgpu::TexelCopyBufferLayout &out, const GPUImageDataLayout &in) { out = {}; return Convert(out.bytesPerRow, in.bytesPerRow) && @@ -502,7 +498,7 @@ class Convertor { Convert(out.cullMode, in.cullMode); } - [[nodiscard]] bool Convert(wgpu::ProgrammableStageDescriptor &out, + [[nodiscard]] bool Convert(wgpu::ComputeState &out, const GPUProgrammableStage &in) { out = {}; out.module = in.module->get(); @@ -554,7 +550,7 @@ class Convertor { Convert(out.stencilReadOnly, in.stencilReadOnly); } - [[nodiscard]] bool Convert(wgpu::RenderPassTimestampWrites &out, + [[nodiscard]] bool Convert(wgpu::PassTimestampWrites &out, const GPURenderPassTimestampWrites &in) { return Convert(out.querySet, in.querySet) && Convert(out.beginningOfPassWriteIndex, diff --git a/packages/webgpu/cpp/rnwgpu/api/GPU.cpp b/packages/webgpu/cpp/rnwgpu/api/GPU.cpp index cb1c1b17e..d1a78d02e 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPU.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPU.cpp @@ -27,15 +27,16 @@ GPU::requestAdapter( aOptions.backendType = kDefaultBackendType; wgpu::Adapter adapter = nullptr; _instance.RequestAdapter( - &aOptions, - [](WGPURequestAdapterStatus, WGPUAdapter cAdapter, - const WGPUStringView message, void *userdata) { + &aOptions, wgpu::CallbackMode::AllowProcessEvents, + [](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter, + wgpu::StringView message, wgpu::Adapter *userdata) { if (message.length) { fprintf(stderr, "%s", message.data); return; } - *static_cast(userdata) = - wgpu::Adapter::Acquire(cAdapter); + if (status == wgpu::RequestAdapterStatus::Success) { + *userdata = std::move(adapter); + } }, &adapter); if (!adapter) { @@ -47,43 +48,43 @@ GPU::requestAdapter( } std::unordered_set GPU::getWgslLanguageFeatures() { - auto count = _instance.EnumerateWGSLLanguageFeatures(nullptr); - std::vector features(count); - _instance.EnumerateWGSLLanguageFeatures(features.data()); + // auto count = _instance.EnumerateWGSLLanguageFeatures(nullptr); + // std::vector features(count); + ///_instance.EnumerateWGSLLanguageFeatures(features.data()); std::unordered_set result; - for (auto feature : features) { - std::string name; - switch (feature) { - case wgpu::WGSLFeatureName::ReadonlyAndReadwriteStorageTextures: - name = "readonly_and_readwrite_storage_textures"; - break; - case wgpu::WGSLFeatureName::Packed4x8IntegerDotProduct: - name = "packed_4x8_integer_dot_product"; - break; - case wgpu::WGSLFeatureName::UnrestrictedPointerParameters: - name = "unrestricted_pointer_parameters"; - break; - case wgpu::WGSLFeatureName::PointerCompositeAccess: - name = "pointer_composite_access"; - break; - case wgpu::WGSLFeatureName::ChromiumTestingUnimplemented: - name = "chromium_testing_unimplemented"; - break; - case wgpu::WGSLFeatureName::ChromiumTestingUnsafeExperimental: - name = "chromium_testing_unsafe_experimental"; - break; - case wgpu::WGSLFeatureName::ChromiumTestingExperimental: - name = "chromium_testing_experimental"; - break; - case wgpu::WGSLFeatureName::ChromiumTestingShippedWithKillswitch: - name = "chromium_testing_shipped_with_killswitch"; - break; - case wgpu::WGSLFeatureName::ChromiumTestingShipped: - name = "chromium_testing_shipped"; - break; - } - result.insert(name); - } + // for (auto feature : features) { + // std::string name; + // switch (feature) { + // case wgpu::WGPUFeatureName::ReadonlyAndReadwriteStorageTextures: + // name = "readonly_and_readwrite_storage_textures"; + // break; + // case wgpu::WGPUFeatureName::Packed4x8IntegerDotProduct: + // name = "packed_4x8_integer_dot_product"; + // break; + // case wgpu::WGPUFeatureName::UnrestrictedPointerParameters: + // name = "unrestricted_pointer_parameters"; + // break; + // case wgpu::WGPUFeatureName::PointerCompositeAccess: + // name = "pointer_composite_access"; + // break; + // case wgpu::WGPUFeatureName::ChromiumTestingUnimplemented: + // name = "chromium_testing_unimplemented"; + // break; + // case wgpu::WGPUFeatureName::ChromiumTestingUnsafeExperimental: + // name = "chromium_testing_unsafe_experimental"; + // break; + // case wgpu::WGPUFeatureName::ChromiumTestingExperimental: + // name = "chromium_testing_experimental"; + // break; + // case wgpu::WGPUFeatureName::ChromiumTestingShippedWithKillswitch: + // name = "chromium_testing_shipped_with_killswitch"; + // break; + // case wgpu::WGPUFeatureName::ChromiumTestingShipped: + // name = "chromium_testing_shipped"; + // break; + // } + // result.insert(name); + // } return result; } diff --git a/packages/webgpu/cpp/rnwgpu/api/GPU.h b/packages/webgpu/cpp/rnwgpu/api/GPU.h index 9b2fc8b17..85da6867e 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPU.h +++ b/packages/webgpu/cpp/rnwgpu/api/GPU.h @@ -12,11 +12,15 @@ #include "AsyncRunner.h" +#include "dawn/dawn_proc.h" +#include "dawn/native/DawnNative.h" #include "webgpu/webgpu_cpp.h" #include "GPUAdapter.h" #include "GPURequestAdapterOptions.h" +#include + namespace rnwgpu { namespace m = margelo; @@ -25,8 +29,8 @@ class GPU : public m::HybridObject { public: GPU() : HybridObject("GPU") { wgpu::InstanceDescriptor instanceDesc; - instanceDesc.features.timedWaitAnyEnable = true; - instanceDesc.features.timedWaitAnyMaxCount = 64; + instanceDesc.capabilities.timedWaitAnyEnable = true; + instanceDesc.capabilities.timedWaitAnyMaxCount = 64; _instance = wgpu::CreateInstance(&instanceDesc); auto instance = &_instance; _async = std::make_shared(instance); diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp index 58b752ff8..d9b6cac38 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp @@ -21,15 +21,17 @@ std::future> GPUAdapter::requestDevice( if (!conv(aDescriptor, descriptor)) { throw std::runtime_error("Failed to convert GPUDeviceDescriptor"); } - wgpu::DeviceLostCallbackInfo info = { - .callback = [](WGPUDevice const *device, WGPUDeviceLostReason reason, - const WGPUStringView message, void *userdata) { + // Set device lost callback using new template API + aDescriptor.SetDeviceLostCallback( + wgpu::CallbackMode::AllowSpontaneous, + [](const wgpu::Device &device, wgpu::DeviceLostReason reason, + wgpu::StringView message) { const char *lostReason = ""; switch (reason) { - case WGPUDeviceLostReason_Destroyed: + case wgpu::DeviceLostReason::Destroyed: lostReason = "Destroyed"; break; - case WGPUDeviceLostReason_Unknown: + case wgpu::DeviceLostReason::Unknown: lostReason = "Unknown"; break; default: @@ -37,43 +39,46 @@ std::future> GPUAdapter::requestDevice( } Logger::logToConsole("GPU Device Lost (%s): %s", lostReason, message.data); - }}; - aDescriptor.deviceLostCallbackInfo = info; - wgpu::UncapturedErrorCallbackInfo errorInfo; - errorInfo.userdata = static_cast(_creationRuntime); - errorInfo.callback = [](WGPUErrorType type, const WGPUStringView message, - void *userdata) { - auto creationRuntime = static_cast(userdata); + }); + + // Set uncaptured error callback using new template API + aDescriptor.SetUncapturedErrorCallback([](const wgpu::Device &device, + wgpu::ErrorType type, + wgpu::StringView message) { const char *errorType = ""; switch (type) { - case WGPUErrorType_Validation: + case wgpu::ErrorType::Validation: errorType = "Validation"; break; - case WGPUErrorType_OutOfMemory: + case wgpu::ErrorType::OutOfMemory: errorType = "Out of Memory"; break; - case WGPUErrorType_Internal: + case wgpu::ErrorType::Internal: errorType = "Internal"; break; - case WGPUErrorType_Unknown: + case wgpu::ErrorType::Unknown: errorType = "Unknown"; break; default: errorType = "Unknown"; } - std::string fullMessage = std::string(errorType) + ": " + message.data; - Logger::errorToJavascriptConsole(*creationRuntime, fullMessage); - }; - aDescriptor.uncapturedErrorCallbackInfo = errorInfo; + std::string fullMessage = + message.length > 0 ? std::string(errorType) + ": " + + std::string(message.data, message.length) + : "no message"; + // TODO: log error + }); _instance.RequestDevice( - &aDescriptor, - [](WGPURequestDeviceStatus status, WGPUDevice cDevice, - const WGPUStringView message, void *userdata) { + &aDescriptor, wgpu::CallbackMode::AllowProcessEvents, + [](wgpu::RequestDeviceStatus status, wgpu::Device device, + wgpu::StringView message, wgpu::Device *userdata) { if (message.length) { fprintf(stderr, "%s", message.data); return; } - *static_cast(userdata) = wgpu::Device::Acquire(cDevice); + if (status == wgpu::RequestDeviceStatus::Success) { + *userdata = std::move(device); + } }, &device); @@ -81,28 +86,32 @@ std::future> GPUAdapter::requestDevice( throw std::runtime_error("Failed to request device"); } device.SetLoggingCallback( - [](WGPULoggingType type, const WGPUStringView message, void *userdata) { - auto creationRuntime = static_cast(userdata); + [creationRuntime = _creationRuntime](wgpu::LoggingType type, + wgpu::StringView message) { const char *logLevel = ""; switch (type) { - case WGPULoggingType_Warning: + case wgpu::LoggingType::Warning: logLevel = "Warning"; - Logger::warnToJavascriptConsole(*creationRuntime, message.data); + Logger::warnToJavascriptConsole( + *creationRuntime, std::string(message.data, message.length)); break; - case WGPULoggingType_Error: + case wgpu::LoggingType::Error: logLevel = "Error"; - Logger::errorToJavascriptConsole(*creationRuntime, message.data); + Logger::errorToJavascriptConsole( + *creationRuntime, std::string(message.data, message.length)); break; - case WGPULoggingType_Verbose: + case wgpu::LoggingType::Verbose: logLevel = "Verbose"; - case WGPULoggingType_Info: + break; + case wgpu::LoggingType::Info: logLevel = "Info"; + break; default: logLevel = "Unknown"; - Logger::logToConsole("%s: %s", logLevel, message); + Logger::logToConsole("%s: %.*s", logLevel, + static_cast(message.length), message.data); } - }, - _creationRuntime); + }); std::string label = descriptor.has_value() ? descriptor.value()->label.value_or("") : ""; promise.set_value( @@ -111,11 +120,11 @@ std::future> GPUAdapter::requestDevice( } std::unordered_set GPUAdapter::getFeatures() { - size_t count = _instance.EnumerateFeatures(nullptr); - std::vector features(count); - _instance.EnumerateFeatures(features.data()); + wgpu::SupportedFeatures supportedFeatures; + _instance.GetFeatures(&supportedFeatures); std::unordered_set 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); if (name != "") { @@ -126,7 +135,7 @@ std::unordered_set GPUAdapter::getFeatures() { } std::shared_ptr GPUAdapter::getLimits() { - wgpu::SupportedLimits limits{}; + wgpu::Limits limits{}; if (!_instance.GetLimits(&limits)) { throw std::runtime_error("Failed to get limits"); } diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUBuffer.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUBuffer.cpp index 85b5bfd92..06c57d9d1 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUBuffer.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUBuffer.cpp @@ -54,25 +54,27 @@ std::future GPUBuffer::mapAsync(uint64_t modeIn, // is already mapped"))); return future; // } // } - wgpu::BufferMapCallbackInfo callback; - callback.mode = wgpu::CallbackMode::WaitAnyOnly; - callback.callback = [](WGPUBufferMapAsyncStatus status, void *userdata) { - switch (status) { - case WGPUBufferMapAsyncStatus_Success: - break; - case WGPUBufferMapAsyncStatus_InstanceDropped: - throw std::runtime_error("WGPUBufferMapAsyncStatus_InstanceDropped"); - break; - case WGPUBufferMapAsyncStatus_ValidationError: - throw std::runtime_error("WGPUBufferMapAsyncStatus_ValidationError"); - break; - default: - throw std::runtime_error("WGPUBufferMapAsyncStatus: " + - std::to_string(status)); - break; - } - }; - return _instance.MapAsync(mode, offset.value_or(0), rangeSize, callback); + return _instance.MapAsync( + mode, offset.value_or(0), rangeSize, wgpu::CallbackMode::WaitAnyOnly, + [](wgpu::MapAsyncStatus status, wgpu::StringView message) { + switch (status) { + case wgpu::MapAsyncStatus::Success: + break; + case wgpu::MapAsyncStatus::CallbackCancelled: + throw std::runtime_error("MapAsyncStatus::CallbackCancelled"); + break; + case wgpu::MapAsyncStatus::Error: + throw std::runtime_error("MapAsyncStatus::Error"); + break; + case wgpu::MapAsyncStatus::Aborted: + throw std::runtime_error("MapAsyncStatus::Aborted"); + break; + default: + throw std::runtime_error("MapAsyncStatus: " + + std::to_string(static_cast(status))); + break; + } + }); }); } diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp index 6fa2afccb..e697afb04 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp @@ -2,10 +2,6 @@ #include "Convertors.h" #include "RNWebGPUManager.h" -#ifdef __APPLE__ -#include "dawn/native/MetalBackend.h" -#endif - namespace rnwgpu { void GPUCanvasContext::configure( @@ -46,10 +42,7 @@ std::shared_ptr GPUCanvasContext::getCurrentTexture() { } void GPUCanvasContext::present() { -#ifdef __APPLE__ - dawn::native::metal::WaitForCommandsToBeScheduled( - _surfaceInfo->getDevice().Get()); -#endif + // TODO: WaitForCommandsToBeScheduled? auto size = _surfaceInfo->getSize(); _canvas->setClientWidth(size.width); _canvas->setClientHeight(size.height); diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUCommandEncoder.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUCommandEncoder.cpp index 67ab413e9..e0e068ad9 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUCommandEncoder.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUCommandEncoder.cpp @@ -64,8 +64,8 @@ void GPUCommandEncoder::copyTextureToBuffer( std::shared_ptr destination, std::shared_ptr 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 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 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) || // diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h b/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h index 86f9b7d54..6e351a493 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h +++ b/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h @@ -22,9 +22,8 @@ struct GPUCompilationMessage { uint64_t linePos; uint64_t offset; uint64_t length; - uint64_t utf16LinePos; - uint64_t utf16Offset; - uint64_t utf16Length; + // utf16LinePos, utf16Offset, utf16Length removed (not available in new WebGPU + // headers) }; class GPUCompilationInfo : public m::HybridObject { @@ -75,12 +74,8 @@ template <> struct JSIConverter> { static_cast(message.offset)); messageObj.setProperty(runtime, "length", static_cast(message.length)); - messageObj.setProperty(runtime, "utf16LinePos", - static_cast(message.utf16LinePos)); - messageObj.setProperty(runtime, "utf16Offset", - static_cast(message.utf16Offset)); - messageObj.setProperty(runtime, "utf16Length", - static_cast(message.utf16Length)); + // utf16LinePos, utf16Offset, utf16Length removed (not available in new + // WebGPU headers) result.setValueAtIndex(runtime, i, messageObj); } return result; diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUDevice.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUDevice.cpp index 5cba6eaf7..2d07422a1 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUDevice.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUDevice.cpp @@ -22,7 +22,7 @@ GPUDevice::createBuffer(std::shared_ptr descriptor) { } std::shared_ptr 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(wgpu::ErrorType::DeviceLost, - message); + result = + std::make_shared(wgpu::ErrorType::Unknown, message); break; default: throw std::runtime_error( @@ -321,13 +320,11 @@ GPUDevice::popErrorScope() { } std::unordered_set GPUDevice::getFeatures() { - size_t count = _instance.EnumerateFeatures(nullptr); - std::vector features(count); - if (count > 0) { - _instance.EnumerateFeatures(features.data()); - } + wgpu::SupportedFeatures supportedFeatures; + _instance.GetFeatures(&supportedFeatures); std::unordered_set 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); diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h b/packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h index 92df8d8bf..e4759610d 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h +++ b/packages/webgpu/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; @@ -83,12 +80,13 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::ANGLETextureSharing: *outUnion = "angle-texture-sharing"; break; - case wgpu::FeatureName::ChromiumExperimentalSubgroups: + case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix: *outUnion = "chromium-experimental-subgroups"; break; - case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow: - *outUnion = "chromium-experimental-subgroup-uniform-control-flow"; - break; + // case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow: // + // Removed + // *outUnion = "chromium-experimental-subgroup-uniform-control-flow"; + // break; case wgpu::FeatureName::PixelLocalStorageCoherent: *outUnion = "pixel-local-storage-coherent"; break; @@ -134,10 +132,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 +183,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: diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUQueue.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUQueue.cpp index 63457a386..2a84eb387 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUQueue.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUQueue.cpp @@ -87,8 +87,8 @@ void GPUQueue::copyExternalImageToTexture( std::shared_ptr source, std::shared_ptr destination, std::shared_ptr 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 destination, std::shared_ptr data, std::shared_ptr dataLayout, std::shared_ptr size) { - wgpu::ImageCopyTexture dst{}; - wgpu::TextureDataLayout layout{}; + wgpu::TexelCopyTextureInfo dst{}; + wgpu::TexelCopyBufferLayout layout{}; wgpu::Extent3D sz{}; Convertor conv; if (!conv(dst, destination) || // diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp index d4f90db27..2db57a38a 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp @@ -25,9 +25,8 @@ 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; + // utf16LinePos, utf16Offset, utf16Length removed (not available + // in new WebGPU headers) result->_messages.push_back(std::move(message)); } } diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp index aa1461d64..9e11734b8 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp @@ -3,131 +3,130 @@ 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; + return _instance.maxVertexBufferArrayStride; } -double GPUSupportedLimits::getMaxInterStageShaderComponents() { - return _instance.limits.maxInterStageShaderComponents; -} +// getMaxInterStageShaderComponents removed (not available in new WebGPU +// headers) 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 diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h index df62f6955..89407b0d6 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h +++ b/packages/webgpu/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,8 @@ class GPUSupportedLimits : public m::HybridObject { double getMaxBufferSize(); double getMaxVertexAttributes(); double getMaxVertexBufferArrayStride(); - double getMaxInterStageShaderComponents(); + // getMaxInterStageShaderComponents removed (not available in new WebGPU + // headers) double getMaxInterStageShaderVariables(); double getMaxColorAttachments(); double getMaxColorAttachmentBytesPerSample(); @@ -117,9 +118,8 @@ class GPUSupportedLimits : public m::HybridObject { registerHybridGetter("maxVertexBufferArrayStride", &GPUSupportedLimits::getMaxVertexBufferArrayStride, this); - registerHybridGetter("maxInterStageShaderComponents", - &GPUSupportedLimits::getMaxInterStageShaderComponents, - this); + // maxInterStageShaderComponents removed (not available in new WebGPU + // headers) registerHybridGetter("maxInterStageShaderVariables", &GPUSupportedLimits::getMaxInterStageShaderVariables, this); @@ -148,10 +148,10 @@ class GPUSupportedLimits : public m::HybridObject { &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 \ No newline at end of file diff --git a/packages/webgpu/cpp/rnwgpu/api/descriptors/Unions.h b/packages/webgpu/cpp/rnwgpu/api/descriptors/Unions.h index ee7e92d7e..991987e08 100644 --- a/packages/webgpu/cpp/rnwgpu/api/descriptors/Unions.h +++ b/packages/webgpu/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") { @@ -443,7 +441,8 @@ static void convertJSUnionToEnum(const std::string &inUnion, } else if (inUnion == "dawn-native") { *outEnum = wgpu::FeatureName::DawnNative; } else if (inUnion == "chromium-experimental-timestamp-query-inside-passes") { - *outEnum = wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses; + *outEnum = + wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses; } else if (inUnion == "implicit-device-synchronization") { *outEnum = wgpu::FeatureName::ImplicitDeviceSynchronization; } else if (inUnion == "transient-attachments") { @@ -457,9 +456,10 @@ static void convertJSUnionToEnum(const std::string &inUnion, } else if (inUnion == "angle-texture-sharing") { *outEnum = wgpu::FeatureName::ANGLETextureSharing; } else if (inUnion == "chromium-experimental-subgroups") { - *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroups; + *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix; } else if (inUnion == "chromium-experimental-subgroup-uniform-control-flow") { - *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow; + // ChromiumExperimentalSubgroupUniformControlFlow removed in new WebGPU + // headers } else if (inUnion == "pixel-local-storage-coherent") { *outEnum = wgpu::FeatureName::PixelLocalStorageCoherent; } else if (inUnion == "pixel-local-storage-non-coherent") { @@ -491,9 +491,9 @@ static void convertJSUnionToEnum(const std::string &inUnion, } else if (inUnion == "r8unorm-storage") { *outEnum = wgpu::FeatureName::R8UnormStorage; } else if (inUnion == "format-capabilities") { - *outEnum = wgpu::FeatureName::FormatCapabilities; + *outEnum = wgpu::FeatureName::DawnFormatCapabilities; } else if (inUnion == "drm-format-capabilities") { - *outEnum = wgpu::FeatureName::DrmFormatCapabilities; + *outEnum = wgpu::FeatureName::DawnDrmFormatCapabilities; } else if (inUnion == "norm16-texture-formats") { *outEnum = wgpu::FeatureName::Norm16TextureFormats; } else if (inUnion == "multi-planar-format-nv16") { @@ -525,7 +525,7 @@ static void convertJSUnionToEnum(const std::string &inUnion, } 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; + *outEnum = wgpu::FeatureName::SharedFenceSyncFD; } else if (inUnion == "shared-fence-vk-semaphore-zircon-handle") { *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle; } else if (inUnion == "shared-fence-dxgi-shared-handle") { @@ -588,9 +588,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,10 +621,11 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::ANGLETextureSharing: *outUnion = "angle-texture-sharing"; break; - case wgpu::FeatureName::ChromiumExperimentalSubgroups: + case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix: *outUnion = "chromium-experimental-subgroups"; break; - case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow: + // case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow: + // // Removed *outUnion = "chromium-experimental-subgroup-uniform-control-flow"; break; case wgpu::FeatureName::PixelLocalStorageCoherent: @@ -675,10 +673,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: @@ -726,7 +724,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: From b9a233ecdf1f5ec4b57e3f95ffae9f8c45748844 Mon Sep 17 00:00:00 2001 From: William Candillon Date: Tue, 3 Jun 2025 21:14:15 +0200 Subject: [PATCH 6/8] :wrench: --- packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h | 1 + packages/webgpu/cpp/rnwgpu/api/GPU.cpp | 2 +- packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp | 4 ++-- packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp | 10 +++++++++- packages/webgpu/package.json | 2 +- 5 files changed, 14 insertions(+), 5 deletions(-) diff --git a/packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h b/packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h index 8ab94678a..fa93c1c1e 100644 --- a/packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h +++ b/packages/webgpu/cpp/rnwgpu/SurfaceRegistry.h @@ -38,6 +38,7 @@ class SurfaceInfo { config = newConfig; config.width = width; config.height = height; + config.presentMode = wgpu::PresentMode::Fifo; _configure(); } diff --git a/packages/webgpu/cpp/rnwgpu/api/GPU.cpp b/packages/webgpu/cpp/rnwgpu/api/GPU.cpp index d1a78d02e..ddc0dcc93 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPU.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPU.cpp @@ -27,7 +27,7 @@ GPU::requestAdapter( aOptions.backendType = kDefaultBackendType; wgpu::Adapter adapter = nullptr; _instance.RequestAdapter( - &aOptions, wgpu::CallbackMode::AllowProcessEvents, + &aOptions, wgpu::CallbackMode::AllowSpontaneous, [](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter, wgpu::StringView message, wgpu::Adapter *userdata) { if (message.length) { diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp index d9b6cac38..3d5a87fdb 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUAdapter.cpp @@ -66,10 +66,10 @@ std::future> GPUAdapter::requestDevice( message.length > 0 ? std::string(errorType) + ": " + std::string(message.data, message.length) : "no message"; - // TODO: log error + fprintf(stderr, "%s", fullMessage.c_str()); }); _instance.RequestDevice( - &aDescriptor, wgpu::CallbackMode::AllowProcessEvents, + &aDescriptor, wgpu::CallbackMode::AllowSpontaneous, [](wgpu::RequestDeviceStatus status, wgpu::Device device, wgpu::StringView message, wgpu::Device *userdata) { if (message.length) { diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp index e697afb04..ea3127420 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp @@ -2,6 +2,10 @@ #include "Convertors.h" #include "RNWebGPUManager.h" +#ifdef __APPLE__ +#include "dawn/native/MetalBackend.h" +#endif + namespace rnwgpu { void GPUCanvasContext::configure( @@ -24,6 +28,7 @@ void GPUCanvasContext::configure( #ifdef __APPLE__ surfaceConfiguration.alphaMode = configuration->alphaMode; #endif + surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo; _surfaceInfo->configure(surfaceConfiguration); } @@ -42,7 +47,10 @@ std::shared_ptr GPUCanvasContext::getCurrentTexture() { } void GPUCanvasContext::present() { - // TODO: WaitForCommandsToBeScheduled? +#ifdef __APPLE__ + dawn::native::metal::WaitForCommandsToBeScheduled( + _surfaceInfo->getDevice().Get()); +#endif auto size = _surfaceInfo->getSize(); _canvas->setClientWidth(size.width); _canvas->setClientHeight(size.height); diff --git a/packages/webgpu/package.json b/packages/webgpu/package.json index a9dd4e96a..af57ea1e6 100644 --- a/packages/webgpu/package.json +++ b/packages/webgpu/package.json @@ -1,6 +1,6 @@ { "name": "react-native-wgpu", - "version": "0.1.23", + "version": "0.2.0", "description": "React Native WebGPU", "main": "lib/commonjs/index", "module": "lib/module/index", From 499155ef0f2158692f365c4b8b003f1b9a47e202 Mon Sep 17 00:00:00 2001 From: William Candillon Date: Tue, 3 Jun 2025 21:31:11 +0200 Subject: [PATCH 7/8] :wrench: --- apps/example/ios/Podfile.lock | 4 +-- .../cpp/rnwgpu/api/GPUCompilationInfo.h | 4 --- packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h | 9 +----- .../webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp | 2 -- .../cpp/rnwgpu/api/GPUSupportedLimits.cpp | 3 -- .../cpp/rnwgpu/api/GPUSupportedLimits.h | 4 --- .../cpp/rnwgpu/api/descriptors/Unions.h | 30 ++++--------------- 7 files changed, 9 insertions(+), 47 deletions(-) diff --git a/apps/example/ios/Podfile.lock b/apps/example/ios/Podfile.lock index 03854e772..42468e9c0 100644 --- a/apps/example/ios/Podfile.lock +++ b/apps/example/ios/Podfile.lock @@ -1433,7 +1433,7 @@ PODS: - ReactCommon/turbomodule/bridging - ReactCommon/turbomodule/core - Yoga - - react-native-wgpu (0.1.23): + - react-native-wgpu (0.2.0): - DoubleConversion - glog - hermes-engine @@ -2246,7 +2246,7 @@ SPEC CHECKSUMS: React-microtasksnativemodule: 054f34e9b82f02bd40f09cebd4083828b5b2beb6 react-native-safe-area-context: 562163222d999b79a51577eda2ea8ad2c32b4d06 react-native-skia: 99362ce77dff006719636c97f16c9713e3ec221e - react-native-wgpu: df332eefb5af27e261fadf5550ef228aaabf279e + react-native-wgpu: 7590eede723b37674adafbb94f0fd0f2acfa32c5 React-NativeModulesApple: 2c4377e139522c3d73f5df582e4f051a838ff25e React-oscompat: ef5df1c734f19b8003e149317d041b8ce1f7d29c React-perflogger: 9a151e0b4c933c9205fd648c246506a83f31395d diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h b/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h index 6e351a493..5908ed212 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h +++ b/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h @@ -22,8 +22,6 @@ struct GPUCompilationMessage { uint64_t linePos; uint64_t offset; uint64_t length; - // utf16LinePos, utf16Offset, utf16Length removed (not available in new WebGPU - // headers) }; class GPUCompilationInfo : public m::HybridObject { @@ -74,8 +72,6 @@ template <> struct JSIConverter> { static_cast(message.offset)); messageObj.setProperty(runtime, "length", static_cast(message.length)); - // utf16LinePos, utf16Offset, utf16Length removed (not available in new - // WebGPU headers) result.setValueAtIndex(runtime, i, messageObj); } return result; diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h b/packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h index e4759610d..4edfb71c4 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h +++ b/packages/webgpu/cpp/rnwgpu/api/GPUFeatures.h @@ -62,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; @@ -81,12 +78,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, *outUnion = "angle-texture-sharing"; break; case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix: - *outUnion = "chromium-experimental-subgroups"; + *outUnion = "chromium-experimental-subgroups-matrix"; break; - // case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow: // - // Removed - // *outUnion = "chromium-experimental-subgroup-uniform-control-flow"; - // break; case wgpu::FeatureName::PixelLocalStorageCoherent: *outUnion = "pixel-local-storage-coherent"; break; diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp index 2db57a38a..6081cb118 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp @@ -25,8 +25,6 @@ GPUShaderModule::getCompilationInfo() { message.linePos = wgpuMessage.linePos; message.offset = wgpuMessage.offset; message.length = wgpuMessage.length; - // utf16LinePos, utf16Offset, utf16Length removed (not available - // in new WebGPU headers) result->_messages.push_back(std::move(message)); } } diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp index 9e11734b8..c2178b5c2 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp @@ -90,9 +90,6 @@ double GPUSupportedLimits::getMaxVertexBufferArrayStride() { return _instance.maxVertexBufferArrayStride; } -// getMaxInterStageShaderComponents removed (not available in new WebGPU -// headers) - double GPUSupportedLimits::getMaxInterStageShaderVariables() { return _instance.maxInterStageShaderVariables; } diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h index 89407b0d6..3f1b6228a 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h +++ b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h @@ -44,8 +44,6 @@ class GPUSupportedLimits : public m::HybridObject { double getMaxBufferSize(); double getMaxVertexAttributes(); double getMaxVertexBufferArrayStride(); - // getMaxInterStageShaderComponents removed (not available in new WebGPU - // headers) double getMaxInterStageShaderVariables(); double getMaxColorAttachments(); double getMaxColorAttachmentBytesPerSample(); @@ -118,8 +116,6 @@ class GPUSupportedLimits : public m::HybridObject { registerHybridGetter("maxVertexBufferArrayStride", &GPUSupportedLimits::getMaxVertexBufferArrayStride, this); - // maxInterStageShaderComponents removed (not available in new WebGPU - // headers) registerHybridGetter("maxInterStageShaderVariables", &GPUSupportedLimits::getMaxInterStageShaderVariables, this); diff --git a/packages/webgpu/cpp/rnwgpu/api/descriptors/Unions.h b/packages/webgpu/cpp/rnwgpu/api/descriptors/Unions.h index 991987e08..45b6202ec 100644 --- a/packages/webgpu/cpp/rnwgpu/api/descriptors/Unions.h +++ b/packages/webgpu/cpp/rnwgpu/api/descriptors/Unions.h @@ -441,8 +441,7 @@ static void convertJSUnionToEnum(const std::string &inUnion, } else if (inUnion == "dawn-native") { *outEnum = wgpu::FeatureName::DawnNative; } else if (inUnion == "chromium-experimental-timestamp-query-inside-passes") { - *outEnum = - wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses; + *outEnum = wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses; } else if (inUnion == "implicit-device-synchronization") { *outEnum = wgpu::FeatureName::ImplicitDeviceSynchronization; } else if (inUnion == "transient-attachments") { @@ -455,11 +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") { + } else if (inUnion == "chromium-experimental-subgroups-matrix") { *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix; - } else if (inUnion == "chromium-experimental-subgroup-uniform-control-flow") { - // ChromiumExperimentalSubgroupUniformControlFlow removed in new WebGPU - // headers } 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") { + } else if (inUnion == "dawn-format-capabilities") { *outEnum = wgpu::FeatureName::DawnFormatCapabilities; - } else if (inUnion == "drm-format-capabilities") { - *outEnum = wgpu::FeatureName::DawnDrmFormatCapabilities; } 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::SharedFenceSyncFD; } else if (inUnion == "shared-fence-vk-semaphore-zircon-handle") { *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle; } else if (inUnion == "shared-fence-dxgi-shared-handle") { @@ -621,12 +613,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::ANGLETextureSharing: *outUnion = "angle-texture-sharing"; break; - case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix: - *outUnion = "chromium-experimental-subgroups"; - break; - // case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow: - // // Removed - *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"; @@ -674,10 +662,7 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, *outUnion = "r8unorm-storage"; break; case wgpu::FeatureName::DawnFormatCapabilities: - *outUnion = "format-capabilities"; - break; - case wgpu::FeatureName::DawnDrmFormatCapabilities: - *outUnion = "drm-format-capabilities"; + *outUnion = "dawn-format-capabilities"; break; case wgpu::FeatureName::Norm16TextureFormats: *outUnion = "norm16-texture-formats"; @@ -724,9 +709,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD: *outUnion = "shared-fence-vk-semaphore-opaque-fd"; break; - case wgpu::FeatureName::SharedFenceSyncFD: - *outUnion = "shared-fence-vk-semaphore-sync-fd"; - break; case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle: *outUnion = "shared-fence-vk-semaphore-zircon-handle"; break; From 34f8802f8838e42742c2d2582d01f3adbd4230ad Mon Sep 17 00:00:00 2001 From: William Candillon Date: Tue, 3 Jun 2025 21:39:46 +0200 Subject: [PATCH 8/8] :wrench: --- packages/webgpu/cpp/rnwgpu/api/GPU.cpp | 73 +++++++++++++------------- 1 file changed, 37 insertions(+), 36 deletions(-) diff --git a/packages/webgpu/cpp/rnwgpu/api/GPU.cpp b/packages/webgpu/cpp/rnwgpu/api/GPU.cpp index ddc0dcc93..ca64fd020 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPU.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPU.cpp @@ -48,43 +48,44 @@ GPU::requestAdapter( } std::unordered_set GPU::getWgslLanguageFeatures() { - // auto count = _instance.EnumerateWGSLLanguageFeatures(nullptr); - // std::vector features(count); - ///_instance.EnumerateWGSLLanguageFeatures(features.data()); + wgpu::SupportedWGSLLanguageFeatures supportedFeatures = {}; + _instance.GetWGSLLanguageFeatures(&supportedFeatures); + std::unordered_set result; - // for (auto feature : features) { - // std::string name; - // switch (feature) { - // case wgpu::WGPUFeatureName::ReadonlyAndReadwriteStorageTextures: - // name = "readonly_and_readwrite_storage_textures"; - // break; - // case wgpu::WGPUFeatureName::Packed4x8IntegerDotProduct: - // name = "packed_4x8_integer_dot_product"; - // break; - // case wgpu::WGPUFeatureName::UnrestrictedPointerParameters: - // name = "unrestricted_pointer_parameters"; - // break; - // case wgpu::WGPUFeatureName::PointerCompositeAccess: - // name = "pointer_composite_access"; - // break; - // case wgpu::WGPUFeatureName::ChromiumTestingUnimplemented: - // name = "chromium_testing_unimplemented"; - // break; - // case wgpu::WGPUFeatureName::ChromiumTestingUnsafeExperimental: - // name = "chromium_testing_unsafe_experimental"; - // break; - // case wgpu::WGPUFeatureName::ChromiumTestingExperimental: - // name = "chromium_testing_experimental"; - // break; - // case wgpu::WGPUFeatureName::ChromiumTestingShippedWithKillswitch: - // name = "chromium_testing_shipped_with_killswitch"; - // break; - // case wgpu::WGPUFeatureName::ChromiumTestingShipped: - // name = "chromium_testing_shipped"; - // break; - // } - // result.insert(name); - // } + for (size_t i = 0; i < supportedFeatures.featureCount; i++) { + wgpu::WGSLLanguageFeatureName feature = supportedFeatures.features[i]; + std::string name; + switch (feature) { + case wgpu::WGSLLanguageFeatureName::ReadonlyAndReadwriteStorageTextures: + name = "readonly_and_readwrite_storage_textures"; + break; + case wgpu::WGSLLanguageFeatureName::Packed4x8IntegerDotProduct: + name = "packed_4x8_integer_dot_product"; + break; + case wgpu::WGSLLanguageFeatureName::UnrestrictedPointerParameters: + name = "unrestricted_pointer_parameters"; + break; + case wgpu::WGSLLanguageFeatureName::PointerCompositeAccess: + name = "pointer_composite_access"; + break; + case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnimplemented: + name = "chromium_testing_unimplemented"; + break; + case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnsafeExperimental: + name = "chromium_testing_unsafe_experimental"; + break; + case wgpu::WGSLLanguageFeatureName::ChromiumTestingExperimental: + name = "chromium_testing_experimental"; + break; + case wgpu::WGSLLanguageFeatureName::ChromiumTestingShippedWithKillswitch: + name = "chromium_testing_shipped_with_killswitch"; + break; + case wgpu::WGSLLanguageFeatureName::ChromiumTestingShipped: + name = "chromium_testing_shipped"; + break; + } + result.insert(name); + } return result; }