@shopify/react-native-skia 2.10.0 → 2.11.0-next.1

package/cpp/dawn/include/webgpu/webgpu_cpp_chained_struct.h

@@ -0,0 +1,57 @@
+// Copyright 2023 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifdef __EMSCRIPTEN__
+#error "Do not include this header. Emscripten already provides headers needed for WebGPU."
+#endif
+
+#ifndef WEBGPU_CPP_CHAINED_STRUCT_H_
+#define WEBGPU_CPP_CHAINED_STRUCT_H_
+
+#include <cstddef>
+#include <cstdint>
+
+// This header file declares the ChainedStruct structures separately from the WebGPU
+// headers so that dependencies can directly extend structures without including the larger header
+// which exposes capabilities that may require correctly set proc tables.
+namespace wgpu {
+
+    enum class SType : uint32_t;
+
+    struct ChainedStruct {
+        ChainedStruct const * nextInChain = nullptr;
+        SType sType = SType(0u);
+    };
+
+    struct ChainedStructOut {
+        ChainedStructOut * nextInChain = nullptr;
+        SType sType = SType(0u);
+    };
+
+}  // namespace wgpu}
+
+#endif // WEBGPU_CPP_CHAINED_STRUCT_H_

package/cpp/dawn/include/webgpu/webgpu_enum_class_bitmasks.h

@@ -0,0 +1,161 @@
+// Copyright 2017 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef WEBGPU_ENUM_CLASS_BITMASKS_H_
+#define WEBGPU_ENUM_CLASS_BITMASKS_H_
+
+#include <type_traits>
+
+// The operators in wgpu:: namespace need be introduced into other namespaces with
+// using-declarations for C++ Argument Dependent Lookup to work.
+#define WGPU_IMPORT_BITMASK_OPERATORS \
+    using wgpu::operator|;            \
+    using wgpu::operator&;            \
+    using wgpu::operator^;            \
+    using wgpu::operator~;            \
+    using wgpu::operator&=;           \
+    using wgpu::operator|=;           \
+    using wgpu::operator^=;           \
+    using wgpu::HasZeroOrOneBits;
+
+namespace wgpu {
+
+template <typename T>
+struct IsWGPUBitmask {
+    static constexpr bool enable = false;
+};
+
+template <typename T, typename Enable = void>
+struct LowerBitmask {
+    static constexpr bool enable = false;
+};
+
+template <typename T>
+struct LowerBitmask<T, typename std::enable_if<IsWGPUBitmask<T>::enable>::type> {
+    static constexpr bool enable = true;
+    using type = T;
+    constexpr static T Lower(T t) { return t; }
+};
+
+template <typename T>
+struct BoolConvertible {
+    using Integral = typename std::underlying_type<T>::type;
+
+    // NOLINTNEXTLINE(runtime/explicit)
+    explicit constexpr BoolConvertible(Integral value) : value(value) {}
+    constexpr operator bool() const { return value != 0; }
+    constexpr operator T() const { return static_cast<T>(value); }
+
+    Integral value;
+};
+
+template <typename T>
+struct LowerBitmask<BoolConvertible<T>> {
+    static constexpr bool enable = true;
+    using type = T;
+    static constexpr type Lower(BoolConvertible<T> t) { return t; }
+};
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator|(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) |
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator&(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) &
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator^(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) ^
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <typename T1>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator~(T1 t) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(~static_cast<Integral>(LowerBitmask<T1>::Lower(t)));
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator&=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l & r;
+    return l;
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator|=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l | r;
+    return l;
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator^=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l ^ r;
+    return l;
+}
+
+template <typename T>
+constexpr bool HasZeroOrOneBits(T value) {
+    using Integral = typename std::underlying_type<T>::type;
+    return (static_cast<Integral>(value) & (static_cast<Integral>(value) - 1)) == 0;
+}
+
+}  // namespace wgpu
+
+#endif  // WEBGPU_ENUM_CLASS_BITMASKS_H_

package/cpp/dawn/include/webgpu/webgpu_glfw.h

@@ -0,0 +1,88 @@
+// Copyright 2022 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef INCLUDE_WEBGPU_WEBGPU_GLFW_H_
+#define INCLUDE_WEBGPU_WEBGPU_GLFW_H_
+
+#ifdef __cplusplus
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+#else
+#include "webgpu/webgpu.h"
+#endif
+
+#if defined(WGPU_GLFW_SHARED_LIBRARY)
+#if defined(_WIN32)
+#if defined(WGPU_GLFW_IMPLEMENTATION)
+#define WGPU_GLFW_EXPORT __declspec(dllexport)
+#else
+#define WGPU_GLFW_EXPORT __declspec(dllimport)
+#endif
+#else  // defined(_WIN32)
+#if defined(WGPU_GLFW_IMPLEMENTATION)
+#define WGPU_GLFW_EXPORT __attribute__((visibility("default")))
+#else
+#define WGPU_GLFW_EXPORT
+#endif
+#endif  // defined(_WIN32)
+#else   // defined(WGPU_GLFW_SHARED_LIBRARY)
+#define WGPU_GLFW_EXPORT
+#endif  // defined(WGPU_GLFW_SHARED_LIBRARY)
+
+struct GLFWwindow;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+WGPU_GLFW_EXPORT WGPUSurface wgpuGlfwCreateSurfaceForWindow(const WGPUInstance instance,
+                                                            struct GLFWwindow* window);
+
+#ifdef __cplusplus
+}
+
+namespace wgpu::glfw {
+
+// Does the necessary setup on the GLFWwindow to allow creating a wgpu::Surface with it and
+// calls `instance.CreateSurface` with the correct descriptor for this window.
+// Returns a null wgpu::Surface on failure.
+WGPU_GLFW_EXPORT wgpu::Surface CreateSurfaceForWindow(const wgpu::Instance& instance,
+                                                      GLFWwindow* window);
+
+// Use for testing only. Does everything that CreateSurfaceForWindow does except the call to
+// CreateSurface. Useful to be able to modify the descriptor for testing, or when trying to
+// avoid using the global proc table.
+// NOLINTNEXTLINE(build/include_what_you_use)
+WGPU_GLFW_EXPORT std::unique_ptr<wgpu::ChainedStruct, void (*)(wgpu::ChainedStruct*)>
+SetupWindowAndGetSurfaceDescriptor(GLFWwindow* window);
+
+}  // namespace wgpu::glfw
+
+#endif
+
+#endif  // INCLUDE_WEBGPU_WEBGPU_GLFW_H_

package/cpp/jsi/JSIConverter.h

@@ -17,11 +17,6 @@
 #include "EnumMapper.h"
 #include "Promise.h"
 
-#ifdef SK_GRAPHITE
-#include "rnwgpu/api/descriptors/Unions.h"
-#include "rnwgpu/async/AsyncTaskHandle.h"
-#endif
-
 // This number is the maximum integer that can be represented exactly as a
 // double
 #define MAX_SAFE_INTEGER static_cast<uint64_t>(9007199254740991)
@@ -212,32 +207,6 @@ struct JSIConverter<TEnum, std::enable_if_t<std::is_enum<TEnum>::value>> {
   }
 };
 
-#ifdef SK_GRAPHITE
-// AsyncTaskHandle <> Promise
-template <> struct JSIConverter<rnwgpu::async::AsyncTaskHandle> {
-  static rnwgpu::async::AsyncTaskHandle fromJSI(jsi::Runtime &,
-                                                const jsi::Value &, bool) {
-    throw std::runtime_error(
-        "Cannot convert a Promise to AsyncTaskHandle on the native side.");
-  }
-
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          rnwgpu::async::AsyncTaskHandle &&handle) {
-    return rnwgpu::Promise::createPromise(
-        runtime, [handle = std::move(handle)](
-                     jsi::Runtime &runtime,
-                     std::shared_ptr<rnwgpu::Promise> promise) mutable {
-          if (!handle.valid()) {
-            promise->resolve(jsi::Value::undefined());
-            return;
-          }
-
-          handle.attachPromise(promise);
-        });
-  }
-};
-#endif
-
 // jsi::Function <> Function
 template <> struct JSIConverter<jsi::Function> {
   static jsi::Function fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,

package/cpp/jsi/NativeObject.h

@@ -392,6 +392,11 @@ protected:
 
   /**
    * Install a method on the prototype.
+   *
+   * The installers below resolve `this` with NativeObject<Derived>::fromValue
+   * (explicitly qualified): derived classes may shadow fromValue with a
+   * public static of the same name that returns the wrapped inner object
+   * (the RNSkia wrappers do), which must not be picked up here.
    */
   template <typename ReturnType, typename... Args>
   static void installMethod(jsi::Runtime &runtime, jsi::Object &prototype,
@@ -401,7 +406,7 @@ protected:
         runtime, jsi::PropNameID::forUtf8(runtime, name), sizeof...(Args),
         [method](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           return callMethod(native.get(), method, rt, args,
                             std::index_sequence_for<Args...>{}, count);
         });
@@ -421,7 +426,7 @@ protected:
         runtime, jsi::PropNameID::forUtf8(runtime, name), sizeof...(Args),
         [method](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           return callMethodWithRuntime(native.get(), method, rt, args,
                                        std::index_sequence_for<Args...>{},
                                        count);
@@ -441,7 +446,7 @@ protected:
         0,
         [getter](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           if constexpr (std::is_same_v<ReturnType, void>) {
             (native.get()->*getter)();
             return jsi::Value::undefined();
@@ -481,7 +486,7 @@ protected:
           if (count < 1) {
             throw jsi::JSError(rt, "Setter requires a value argument");
           }
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           auto value = rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(
               rt, args[0], false);
           (native.get()->*setter)(std::move(value));
@@ -528,7 +533,7 @@ protected:
         0,
         [getter](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           ReturnType result = (native.get()->*getter)();
           return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(
               rt, std::move(result));
@@ -542,7 +547,7 @@ protected:
           if (count < 1) {
             throw jsi::JSError(rt, "Setter requires a value argument");
           }
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           auto value = rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(
               rt, args[0], false);
           (native.get()->*setter)(std::move(value));

package/cpp/rnskia/RNDawnContext.h

@@ -366,8 +366,9 @@ private:
   std::mutex _mutex;
 
   DawnContext() {
-    DawnProcTable backendProcs = dawn::native::GetProcs();
-    dawnProcSetProcs(&backendProcs);
+    // No dawnProcSetProcs() here: the monolithic libwebgpu_dawn (shared with
+    // react-native-webgpu) exposes the real wgpu* C entry points directly
+    // rather than the settable dawn_proc trampoline, which it does not ship.
     static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
 
     wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
@@ -376,6 +377,21 @@ private:
     // For limits:
     wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
     instanceDesc.requiredLimits = &limits;
+
+    // Same instance-stage toggles react-native-webgpu sets on its own
+    // instance: when webgpu adopts this instance (rnskia_getWGPUInstance),
+    // its external-texture path expects experimental adapter features to be
+    // visible. These only un-hide features in adapter.features; nothing
+    // becomes active unless a device requests it.
+    static const char *const kInstanceToggles[] = {
+        "allow_unsafe_apis",
+        "expose_wgsl_experimental_features",
+    };
+    wgpu::DawnTogglesDescriptor instanceToggles;
+    instanceToggles.enabledToggleCount = std::size(kInstanceToggles);
+    instanceToggles.enabledToggles = kInstanceToggles;
+    instanceDesc.nextInChain = &instanceToggles;
+
     instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
 
     backendContext = DawnUtils::createDawnBackendContext(instance.get());

package/cpp/rnskia/RNDawnInterop.cpp

@@ -0,0 +1,19 @@
+#ifdef SK_GRAPHITE
+
+#include "RNDawnContext.h"
+
+// Runtime discovery surface for react-native-webgpu.
+//
+// webgpu looks this symbol up with dlsym(RTLD_DEFAULT, ...) when it creates
+// its GPU object and, when found, adopts the returned instance instead of
+// creating its own. Sharing one wgpu::Instance across both packages makes
+// pointer-based device handoff (RNWebGPU.importDevice(Skia.getNativeDevice()))
+// sound: async callbacks of imported devices settle on the instance webgpu
+// pumps. Plain C, default visibility: no C++ ABI surface, works across
+// separately compiled pods, and stays dlsym-able under -fvisibility=hidden.
+extern "C" __attribute__((visibility("default"))) WGPUInstance
+rnskia_getWGPUInstance() {
+  return RNSkia::DawnContext::getInstance().getWGPUInstance().Get();
+}
+
+#endif

package/cpp/rnskia/RNDawnUtils.h

@@ -1,8 +1,11 @@
 #pragma once
 
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
 #include "webgpu/webgpu_cpp.h"
 
-#include "dawn/dawn_proc.h"
 #include "dawn/native/DawnNative.h"
 
 #include "include/core/SkColorType.h"
@@ -115,6 +118,20 @@ requestDevice(dawn::native::Adapter &nativeAdapter,
   wgpu::DawnTogglesDescriptor togglesDesc;
   togglesDesc.enabledToggleCount = std::size(kToggles);
   togglesDesc.enabledToggles = kToggles;
+#if defined(TARGET_OS_SIMULATOR) && TARGET_OS_SIMULATOR
+  // The iOS Simulator only advertises MTLFeatureSet_iOS_GPUFamily2, so Dawn
+  // defaults disable_base_instance/disable_base_vertex on and then rejects
+  // every draw with a non-zero firstInstance or baseVertex, which Graphite
+  // emits routinely. The simulator forwards Metal calls to the host GPU,
+  // which does support base vertex/instance drawing, so force the toggles
+  // off. Device builds are unaffected: Graphite-capable iPhones and iPads
+  // are all GPUFamily3+. (Same override as react-native-webgpu; see
+  // https://issues.chromium.org/issues/42241591.)
+  static constexpr const char *kDisabledToggles[] = {"disable_base_instance",
+                                                     "disable_base_vertex"};
+  togglesDesc.disabledToggleCount = std::size(kDisabledToggles);
+  togglesDesc.disabledToggles = kDisabledToggles;
+#endif
 
   wgpu::DeviceDescriptor desc;
   desc.requiredFeatureCount = features.size();