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/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/externals/dawn b/externals/dawn index a690fe423..56a4aec00 160000 --- a/externals/dawn +++ b/externals/dawn @@ -1 +1 @@ -Subproject commit a690fe42392c8b8043a37fbfbbb69d0f5a02c814 +Subproject commit 56a4aec006181ed29853e5cd2bdd6a237798c958 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..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(); } @@ -83,10 +84,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..ca64fd020 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::AllowSpontaneous, + [](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,38 +48,39 @@ 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) { + for (size_t i = 0; i < supportedFeatures.featureCount; i++) { + wgpu::WGSLLanguageFeatureName feature = supportedFeatures.features[i]; std::string name; switch (feature) { - case wgpu::WGSLFeatureName::ReadonlyAndReadwriteStorageTextures: + case wgpu::WGSLLanguageFeatureName::ReadonlyAndReadwriteStorageTextures: name = "readonly_and_readwrite_storage_textures"; break; - case wgpu::WGSLFeatureName::Packed4x8IntegerDotProduct: + case wgpu::WGSLLanguageFeatureName::Packed4x8IntegerDotProduct: name = "packed_4x8_integer_dot_product"; break; - case wgpu::WGSLFeatureName::UnrestrictedPointerParameters: + case wgpu::WGSLLanguageFeatureName::UnrestrictedPointerParameters: name = "unrestricted_pointer_parameters"; break; - case wgpu::WGSLFeatureName::PointerCompositeAccess: + case wgpu::WGSLLanguageFeatureName::PointerCompositeAccess: name = "pointer_composite_access"; break; - case wgpu::WGSLFeatureName::ChromiumTestingUnimplemented: + case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnimplemented: name = "chromium_testing_unimplemented"; break; - case wgpu::WGSLFeatureName::ChromiumTestingUnsafeExperimental: + case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnsafeExperimental: name = "chromium_testing_unsafe_experimental"; break; - case wgpu::WGSLFeatureName::ChromiumTestingExperimental: + case wgpu::WGSLLanguageFeatureName::ChromiumTestingExperimental: name = "chromium_testing_experimental"; break; - case wgpu::WGSLFeatureName::ChromiumTestingShippedWithKillswitch: + case wgpu::WGSLLanguageFeatureName::ChromiumTestingShippedWithKillswitch: name = "chromium_testing_shipped_with_killswitch"; break; - case wgpu::WGSLFeatureName::ChromiumTestingShipped: + case wgpu::WGSLLanguageFeatureName::ChromiumTestingShipped: name = "chromium_testing_shipped"; break; } 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..3d5a87fdb 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"; + fprintf(stderr, "%s", fullMessage.c_str()); + }); _instance.RequestDevice( - &aDescriptor, - [](WGPURequestDeviceStatus status, WGPUDevice cDevice, - const WGPUStringView message, void *userdata) { + &aDescriptor, wgpu::CallbackMode::AllowSpontaneous, + [](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..ea3127420 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.cpp @@ -28,6 +28,7 @@ void GPUCanvasContext::configure( #ifdef __APPLE__ surfaceConfiguration.alphaMode = configuration->alphaMode; #endif + surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo; _surfaceInfo->configure(surfaceConfiguration); } 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..5908ed212 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h +++ b/packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h @@ -22,9 +22,6 @@ struct GPUCompilationMessage { uint64_t linePos; uint64_t offset; uint64_t length; - uint64_t utf16LinePos; - uint64_t utf16Offset; - uint64_t utf16Length; }; class GPUCompilationInfo : public m::HybridObject { @@ -75,12 +72,6 @@ template <> struct JSIConverter> { 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)); 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..4edfb71c4 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; @@ -65,9 +62,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::ImplicitDeviceSynchronization: *outUnion = "implicit-device-synchronization"; break; - // case wgpu::FeatureName::SurfaceCapabilities: - // *outUnion = "surface-capabilities"; - // break; case wgpu::FeatureName::TransientAttachments: *outUnion = "transient-attachments"; break; @@ -83,11 +77,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::ANGLETextureSharing: *outUnion = "angle-texture-sharing"; break; - case wgpu::FeatureName::ChromiumExperimentalSubgroups: - *outUnion = "chromium-experimental-subgroups"; - break; - case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow: - *outUnion = "chromium-experimental-subgroup-uniform-control-flow"; + case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix: + *outUnion = "chromium-experimental-subgroups-matrix"; break; case wgpu::FeatureName::PixelLocalStorageCoherent: *outUnion = "pixel-local-storage-coherent"; @@ -134,10 +125,10 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::R8UnormStorage: *outUnion = "r8unorm-storage"; break; - case wgpu::FeatureName::FormatCapabilities: + case wgpu::FeatureName::DawnFormatCapabilities: *outUnion = "format-capabilities"; break; - case wgpu::FeatureName::DrmFormatCapabilities: + case wgpu::FeatureName::DawnDrmFormatCapabilities: *outUnion = "drm-format-capabilities"; break; case wgpu::FeatureName::Norm16TextureFormats: @@ -185,7 +176,7 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD: *outUnion = "shared-fence-vk-semaphore-opaque-fd"; break; - case wgpu::FeatureName::SharedFenceVkSemaphoreSyncFD: + case wgpu::FeatureName::SharedFenceSyncFD: *outUnion = "shared-fence-vk-semaphore-sync-fd"; break; case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle: 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..6081cb118 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUShaderModule.cpp @@ -25,9 +25,6 @@ GPUShaderModule::getCompilationInfo() { message.linePos = wgpuMessage.linePos; message.offset = wgpuMessage.offset; message.length = wgpuMessage.length; - message.utf16LinePos = wgpuMessage.utf16LinePos; - message.utf16Offset = wgpuMessage.utf16Offset; - message.utf16Length = wgpuMessage.utf16Length; result->_messages.push_back(std::move(message)); } } diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp index aa1461d64..c2178b5c2 100644 --- a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp +++ b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.cpp @@ -3,131 +3,127 @@ namespace rnwgpu { double GPUSupportedLimits::getMaxTextureDimension1D() { - return _instance.limits.maxTextureDimension1D; + return _instance.maxTextureDimension1D; } double GPUSupportedLimits::getMaxTextureDimension2D() { - return _instance.limits.maxTextureDimension2D; + return _instance.maxTextureDimension2D; } double GPUSupportedLimits::getMaxTextureDimension3D() { - return _instance.limits.maxTextureDimension3D; + return _instance.maxTextureDimension3D; } double GPUSupportedLimits::getMaxTextureArrayLayers() { - return _instance.limits.maxTextureArrayLayers; + return _instance.maxTextureArrayLayers; } double GPUSupportedLimits::getMaxBindGroups() { - return _instance.limits.maxBindGroups; + return _instance.maxBindGroups; } double GPUSupportedLimits::getMaxBindGroupsPlusVertexBuffers() { - return _instance.limits.maxBindGroupsPlusVertexBuffers; + return _instance.maxBindGroupsPlusVertexBuffers; } double GPUSupportedLimits::getMaxBindingsPerBindGroup() { - return _instance.limits.maxBindingsPerBindGroup; + return _instance.maxBindingsPerBindGroup; } double GPUSupportedLimits::getMaxDynamicUniformBuffersPerPipelineLayout() { - return _instance.limits.maxDynamicUniformBuffersPerPipelineLayout; + return _instance.maxDynamicUniformBuffersPerPipelineLayout; } double GPUSupportedLimits::getMaxDynamicStorageBuffersPerPipelineLayout() { - return _instance.limits.maxDynamicStorageBuffersPerPipelineLayout; + return _instance.maxDynamicStorageBuffersPerPipelineLayout; } double GPUSupportedLimits::getMaxSampledTexturesPerShaderStage() { - return _instance.limits.maxSampledTexturesPerShaderStage; + return _instance.maxSampledTexturesPerShaderStage; } double GPUSupportedLimits::getMaxSamplersPerShaderStage() { - return _instance.limits.maxSamplersPerShaderStage; + return _instance.maxSamplersPerShaderStage; } double GPUSupportedLimits::getMaxStorageBuffersPerShaderStage() { - return _instance.limits.maxStorageBuffersPerShaderStage; + return _instance.maxStorageBuffersPerShaderStage; } double GPUSupportedLimits::getMaxStorageTexturesPerShaderStage() { - return _instance.limits.maxStorageTexturesPerShaderStage; + return _instance.maxStorageTexturesPerShaderStage; } double GPUSupportedLimits::getMaxUniformBuffersPerShaderStage() { - return _instance.limits.maxUniformBuffersPerShaderStage; + return _instance.maxUniformBuffersPerShaderStage; } double GPUSupportedLimits::getMaxUniformBufferBindingSize() { - return _instance.limits.maxUniformBufferBindingSize; + return _instance.maxUniformBufferBindingSize; } double GPUSupportedLimits::getMaxStorageBufferBindingSize() { - return _instance.limits.maxStorageBufferBindingSize; + return _instance.maxStorageBufferBindingSize; } double GPUSupportedLimits::getMinUniformBufferOffsetAlignment() { - return _instance.limits.minUniformBufferOffsetAlignment; + return _instance.minUniformBufferOffsetAlignment; } double GPUSupportedLimits::getMinStorageBufferOffsetAlignment() { - return _instance.limits.minStorageBufferOffsetAlignment; + return _instance.minStorageBufferOffsetAlignment; } double GPUSupportedLimits::getMaxVertexBuffers() { - return _instance.limits.maxVertexBuffers; + return _instance.maxVertexBuffers; } double GPUSupportedLimits::getMaxBufferSize() { - return _instance.limits.maxBufferSize; + return _instance.maxBufferSize; } double GPUSupportedLimits::getMaxVertexAttributes() { - return _instance.limits.maxVertexAttributes; + return _instance.maxVertexAttributes; } double GPUSupportedLimits::getMaxVertexBufferArrayStride() { - return _instance.limits.maxVertexBufferArrayStride; -} - -double GPUSupportedLimits::getMaxInterStageShaderComponents() { - return _instance.limits.maxInterStageShaderComponents; + return _instance.maxVertexBufferArrayStride; } double GPUSupportedLimits::getMaxInterStageShaderVariables() { - return _instance.limits.maxInterStageShaderVariables; + return _instance.maxInterStageShaderVariables; } double GPUSupportedLimits::getMaxColorAttachments() { - return _instance.limits.maxColorAttachments; + return _instance.maxColorAttachments; } double GPUSupportedLimits::getMaxColorAttachmentBytesPerSample() { - return _instance.limits.maxColorAttachmentBytesPerSample; + return _instance.maxColorAttachmentBytesPerSample; } double GPUSupportedLimits::getMaxComputeWorkgroupStorageSize() { - return _instance.limits.maxComputeWorkgroupStorageSize; + return _instance.maxComputeWorkgroupStorageSize; } double GPUSupportedLimits::getMaxComputeInvocationsPerWorkgroup() { - return _instance.limits.maxComputeInvocationsPerWorkgroup; + return _instance.maxComputeInvocationsPerWorkgroup; } double GPUSupportedLimits::getMaxComputeWorkgroupSizeX() { - return _instance.limits.maxComputeWorkgroupSizeX; + return _instance.maxComputeWorkgroupSizeX; } double GPUSupportedLimits::getMaxComputeWorkgroupSizeY() { - return _instance.limits.maxComputeWorkgroupSizeY; + return _instance.maxComputeWorkgroupSizeY; } double GPUSupportedLimits::getMaxComputeWorkgroupSizeZ() { - return _instance.limits.maxComputeWorkgroupSizeZ; + return _instance.maxComputeWorkgroupSizeZ; } double GPUSupportedLimits::getMaxComputeWorkgroupsPerDimension() { - return _instance.limits.maxComputeWorkgroupsPerDimension; + return _instance.maxComputeWorkgroupsPerDimension; } } // namespace rnwgpu diff --git a/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h b/packages/webgpu/cpp/rnwgpu/api/GPUSupportedLimits.h index df62f6955..3f1b6228a 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,6 @@ class GPUSupportedLimits : public m::HybridObject { double getMaxBufferSize(); double getMaxVertexAttributes(); double getMaxVertexBufferArrayStride(); - double getMaxInterStageShaderComponents(); double getMaxInterStageShaderVariables(); double getMaxColorAttachments(); double getMaxColorAttachmentBytesPerSample(); @@ -117,9 +116,6 @@ class GPUSupportedLimits : public m::HybridObject { registerHybridGetter("maxVertexBufferArrayStride", &GPUSupportedLimits::getMaxVertexBufferArrayStride, this); - registerHybridGetter("maxInterStageShaderComponents", - &GPUSupportedLimits::getMaxInterStageShaderComponents, - this); registerHybridGetter("maxInterStageShaderVariables", &GPUSupportedLimits::getMaxInterStageShaderVariables, this); @@ -148,10 +144,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..45b6202ec 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") { @@ -456,10 +454,8 @@ static void convertJSUnionToEnum(const std::string &inUnion, *outEnum = wgpu::FeatureName::D3D11MultithreadProtected; } else if (inUnion == "angle-texture-sharing") { *outEnum = wgpu::FeatureName::ANGLETextureSharing; - } else if (inUnion == "chromium-experimental-subgroups") { - *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroups; - } else if (inUnion == "chromium-experimental-subgroup-uniform-control-flow") { - *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow; + } else if (inUnion == "chromium-experimental-subgroups-matrix") { + *outEnum = wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix; } else if (inUnion == "pixel-local-storage-coherent") { *outEnum = wgpu::FeatureName::PixelLocalStorageCoherent; } else if (inUnion == "pixel-local-storage-non-coherent") { @@ -490,10 +486,8 @@ static void convertJSUnionToEnum(const std::string &inUnion, *outEnum = wgpu::FeatureName::AdapterPropertiesVk; } else if (inUnion == "r8unorm-storage") { *outEnum = wgpu::FeatureName::R8UnormStorage; - } else if (inUnion == "format-capabilities") { - *outEnum = wgpu::FeatureName::FormatCapabilities; - } else if (inUnion == "drm-format-capabilities") { - *outEnum = wgpu::FeatureName::DrmFormatCapabilities; + } else if (inUnion == "dawn-format-capabilities") { + *outEnum = wgpu::FeatureName::DawnFormatCapabilities; } else if (inUnion == "norm16-texture-formats") { *outEnum = wgpu::FeatureName::Norm16TextureFormats; } else if (inUnion == "multi-planar-format-nv16") { @@ -524,8 +518,6 @@ static void convertJSUnionToEnum(const std::string &inUnion, *outEnum = wgpu::FeatureName::SharedTextureMemoryEGLImage; } else if (inUnion == "shared-fence-vk-semaphore-opaque-fd") { *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD; - } else if (inUnion == "shared-fence-vk-semaphore-sync-fd") { - *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreSyncFD; } else if (inUnion == "shared-fence-vk-semaphore-zircon-handle") { *outEnum = wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle; } else if (inUnion == "shared-fence-dxgi-shared-handle") { @@ -588,9 +580,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::Subgroups: *outUnion = "subgroups"; break; - case wgpu::FeatureName::SubgroupsF16: - *outUnion = "subgroups-f16"; - break; case wgpu::FeatureName::DawnInternalUsages: *outUnion = "dawn-internal-usages"; break; @@ -624,11 +613,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::ANGLETextureSharing: *outUnion = "angle-texture-sharing"; break; - case wgpu::FeatureName::ChromiumExperimentalSubgroups: - *outUnion = "chromium-experimental-subgroups"; - break; - case wgpu::FeatureName::ChromiumExperimentalSubgroupUniformControlFlow: - *outUnion = "chromium-experimental-subgroup-uniform-control-flow"; + case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix: + *outUnion = "chromium-experimental-subgroups-matrix"; break; case wgpu::FeatureName::PixelLocalStorageCoherent: *outUnion = "pixel-local-storage-coherent"; @@ -675,11 +661,8 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::R8UnormStorage: *outUnion = "r8unorm-storage"; break; - case wgpu::FeatureName::FormatCapabilities: - *outUnion = "format-capabilities"; - break; - case wgpu::FeatureName::DrmFormatCapabilities: - *outUnion = "drm-format-capabilities"; + case wgpu::FeatureName::DawnFormatCapabilities: + *outUnion = "dawn-format-capabilities"; break; case wgpu::FeatureName::Norm16TextureFormats: *outUnion = "norm16-texture-formats"; @@ -726,9 +709,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum, case wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD: *outUnion = "shared-fence-vk-semaphore-opaque-fd"; break; - case wgpu::FeatureName::SharedFenceVkSemaphoreSyncFD: - *outUnion = "shared-fence-vk-semaphore-sync-fd"; - break; case wgpu::FeatureName::SharedFenceVkSemaphoreZirconHandle: *outUnion = "shared-fence-vk-semaphore-zircon-handle"; break; 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",