@shopify/react-native-skia 2.5.5 → 2.6.0

package/cpp/api/JsiSkPathFactory.h

@@ -1,19 +1,31 @@
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include <jsi/jsi.h>
 
 #include "JsiSkHostObjects.h"
+#include "JsiSkMatrix.h"
 #include "JsiSkPathEffect.h"
+#include "JsiSkPoint.h"
+#include "JsiSkRRect.h"
+#include "JsiSkRect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
 #include "RNSkLog.h"
 #include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkPathUtils.h"
+#include "include/core/SkStrokeRec.h"
+#include "include/effects/SkDashPathEffect.h"
+#include "include/effects/SkTrimPathEffect.h"
 #include "include/pathops/SkPathOps.h"
+#include "include/utils/SkTextUtils.h"
 
 #pragma clang diagnostic pop
 
@@ -54,8 +66,8 @@ public:
   }
 
   JSI_HOST_FUNCTION(MakeFromOp) {
-    SkPath one = *JsiSkPath::fromValue(runtime, arguments[0]).get();
-    SkPath two = *JsiSkPath::fromValue(runtime, arguments[1]).get();
+    SkPath one = JsiSkPath::fromValue(runtime, arguments[0])->snapshot();
+    SkPath two = JsiSkPath::fromValue(runtime, arguments[1])->snapshot();
     SkPathOp op = (SkPathOp)arguments[2].asNumber();
     SkPath result;
     bool success = Op(one, two, op, &result);
@@ -170,6 +182,251 @@ public:
         runtime, hostObjectInstance, getContext());
   }
 
+  // Static shape factories
+  JSI_HOST_FUNCTION(Rect) {
+    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
+    auto direction = SkPathDirection::kCW;
+    if (count >= 2 && arguments[1].getBool()) {
+      direction = SkPathDirection::kCCW;
+    }
+    SkPath path;
+    path.addRect(*rect, direction);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  JSI_HOST_FUNCTION(Oval) {
+    auto rect = JsiSkRect::fromValue(runtime, arguments[0]);
+    auto direction = SkPathDirection::kCW;
+    if (count >= 2 && arguments[1].getBool()) {
+      direction = SkPathDirection::kCCW;
+    }
+    unsigned startIndex = count < 3 ? 0 : arguments[2].asNumber();
+    SkPath path;
+    path.addOval(*rect, direction, startIndex);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  JSI_HOST_FUNCTION(Circle) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    auto r = arguments[2].asNumber();
+    SkPath path;
+    path.addCircle(x, y, r);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  JSI_HOST_FUNCTION(RRect) {
+    auto rrect = JsiSkRRect::fromValue(runtime, arguments[0]);
+    auto direction = SkPathDirection::kCW;
+    if (count >= 2 && arguments[1].getBool()) {
+      direction = SkPathDirection::kCCW;
+    }
+    SkPath path;
+    path.addRRect(*rrect, direction);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  JSI_HOST_FUNCTION(Line) {
+    auto p1 = JsiSkPoint::fromValue(
+        runtime, arguments[0].asObject(runtime));
+    auto p2 = JsiSkPoint::fromValue(
+        runtime, arguments[1].asObject(runtime));
+    SkPath path;
+    path.moveTo(*p1);
+    path.lineTo(*p2);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  JSI_HOST_FUNCTION(Polygon) {
+    std::vector<SkPoint> points;
+    auto jsiPoints = arguments[0].asObject(runtime).asArray(runtime);
+    auto close = arguments[1].getBool();
+    auto pointsSize = jsiPoints.size(runtime);
+    points.reserve(pointsSize);
+    for (int i = 0; i < pointsSize; i++) {
+      std::shared_ptr<SkPoint> point = JsiSkPoint::fromValue(
+          runtime, jsiPoints.getValueAtIndex(runtime, i).asObject(runtime));
+      points.push_back(*point.get());
+    }
+    SkPath path;
+    auto p = SkSpan(points.data(), points.size());
+    path.addPoly(p, close);
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(path));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
+  // Static path operations
+  JSI_HOST_FUNCTION(Stroke) {
+    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+    SkPath path = srcPath->snapshot();
+    SkPaint p;
+    p.setStyle(SkPaint::kStroke_Style);
+
+    if (count > 1 && !arguments[1].isUndefined()) {
+      auto opts = arguments[1].asObject(runtime);
+
+      auto jsiCap = opts.getProperty(runtime, "cap");
+      if (!jsiCap.isUndefined()) {
+        auto cap = (SkPaint::Cap)jsiCap.asNumber();
+        p.setStrokeCap(cap);
+      }
+
+      auto jsiJoin = opts.getProperty(runtime, "join");
+      if (!jsiJoin.isUndefined()) {
+        auto join = (SkPaint::Join)jsiJoin.asNumber();
+        p.setStrokeJoin(join);
+      }
+
+      auto jsiWidth = opts.getProperty(runtime, "width");
+      if (!jsiWidth.isUndefined()) {
+        auto width = jsiWidth.asNumber();
+        p.setStrokeWidth(width);
+      }
+
+      auto jsiMiterLimit = opts.getProperty(runtime, "miter_limit");
+      if (!jsiMiterLimit.isUndefined()) {
+        auto miter_limit = jsiMiterLimit.asNumber();
+        p.setStrokeMiter(miter_limit);
+      }
+
+      auto jsiPrecision = opts.getProperty(runtime, "precision");
+      auto precision = jsiPrecision.isUndefined() ? 1 : jsiPrecision.asNumber();
+      SkPath result;
+      auto success =
+          skpathutils::FillPathWithPaint(path, p, &result, nullptr, precision);
+      if (success) {
+        auto hostObjectInstance =
+            std::make_shared<JsiSkPath>(getContext(), std::move(result));
+        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+            runtime, hostObjectInstance, getContext());
+      }
+    } else {
+      SkPath result;
+      auto success =
+          skpathutils::FillPathWithPaint(path, p, &result, nullptr, 1);
+      if (success) {
+        auto hostObjectInstance =
+            std::make_shared<JsiSkPath>(getContext(), std::move(result));
+        return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+            runtime, hostObjectInstance, getContext());
+      }
+    }
+    return jsi::Value::null();
+  }
+
+  JSI_HOST_FUNCTION(Trim) {
+    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+    float start = std::clamp(static_cast<float>(arguments[1].asNumber()), 0.0f, 1.0f);
+    float end = std::clamp(static_cast<float>(arguments[2].asNumber()), 0.0f, 1.0f);
+    auto isComplement = arguments[3].getBool();
+    // If requesting the full path in normal mode, just return a copy
+    if (start <= 0 && end >= 1 && !isComplement) {
+      SkPath result = srcPath->snapshot();
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    SkPath path = srcPath->snapshot();
+    auto mode = isComplement ? SkTrimPathEffect::Mode::kInverted
+                             : SkTrimPathEffect::Mode::kNormal;
+    auto pe = SkTrimPathEffect::Make(start, end, mode);
+    if (!pe) {
+      return jsi::Value::null();
+    }
+    SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
+    SkPathBuilder resultBuilder;
+    if (pe->filterPath(&resultBuilder, path, &rec)) {
+      auto result = resultBuilder.detach();
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    return jsi::Value::null();
+  }
+
+  JSI_HOST_FUNCTION(Simplify) {
+    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+    auto result = ::Simplify(srcPath->snapshot());
+    if (result.has_value()) {
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    return jsi::Value::null();
+  }
+
+  JSI_HOST_FUNCTION(Dash) {
+    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+    SkScalar on = arguments[1].asNumber();
+    SkScalar off = arguments[2].asNumber();
+    auto phase = arguments[3].asNumber();
+    SkScalar intervals[] = {on, off};
+    auto i = SkSpan(intervals, 2);
+    auto pe = SkDashPathEffect::Make(i, phase);
+    if (!pe) {
+      return jsi::Value::null();
+    }
+    SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
+    SkPathBuilder resultBuilder;
+    if (pe->filterPath(&resultBuilder, srcPath->snapshot(), &rec)) {
+      auto result = resultBuilder.detach();
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    return jsi::Value::null();
+  }
+
+  JSI_HOST_FUNCTION(AsWinding) {
+    auto srcPath = JsiSkPath::fromValue(runtime, arguments[0]);
+    auto result = ::AsWinding(srcPath->snapshot());
+    if (result.has_value()) {
+      auto hostObjectInstance =
+          std::make_shared<JsiSkPath>(getContext(), std::move(result.value()));
+      return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+          runtime, hostObjectInstance, getContext());
+    }
+    return jsi::Value::null();
+  }
+
+  JSI_HOST_FUNCTION(Interpolate) {
+    auto path1 = JsiSkPath::fromValue(runtime, arguments[0]);
+    auto path2 = JsiSkPath::fromValue(runtime, arguments[1]);
+    auto weight = arguments[2].asNumber();
+    auto p1 = path1->snapshot();
+    auto p2 = path2->snapshot();
+    SkPath result;
+    auto succeed = p1.interpolate(p2, weight, &result);
+    if (!succeed) {
+      return jsi::Value::null();
+    }
+    auto hostObjectInstance =
+        std::make_shared<JsiSkPath>(getContext(), std::move(result));
+    return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(
+        runtime, hostObjectInstance, getContext());
+  }
+
   size_t getMemoryPressure() const override { return 1024; }
 
   std::string getObjectType() const override { return "JsiSkPathFactory"; }
@@ -178,7 +435,21 @@ public:
                        JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromSVGString),
                        JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromOp),
                        JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromCmds),
-                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromText))
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, MakeFromText),
+                       // Static shape factories
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Rect),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Oval),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Circle),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, RRect),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Line),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Polygon),
+                       // Static path operations
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Stroke),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Trim),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Simplify),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Dash),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, AsWinding),
+                       JSI_EXPORT_FUNC(JsiSkPathFactory, Interpolate))
 
   explicit JsiSkPathFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/recorder/DataTypes.h

@@ -141,7 +141,7 @@ std::shared_ptr<SkPath> processPath(jsi::Runtime &runtime,
     auto ptr = std::dynamic_pointer_cast<JsiSkPath>(
         value.asObject(runtime).asHostObject(runtime));
     if (ptr != nullptr) {
-      return ptr->getObject();
+      return std::make_shared<SkPath>(ptr->getObject()->snapshot());
     }
   }
   return nullptr;

package/cpp/api/recorder/Drawings.h

@@ -8,6 +8,9 @@
 #include "ImageFit.h"
 #include "RNSkPlatformContext.h"
 
+#include "include/core/SkPathBuilder.h"
+#include "include/core/SkStrokeRec.h"
+
 namespace RNSkia {
 
 struct CircleCmdProps {
@@ -123,12 +126,13 @@ public:
             SkTrimPathEffect::Make(start, end, SkTrimPathEffect::Mode::kNormal);
         if (pe != nullptr) {
           SkStrokeRec rec(SkStrokeRec::InitStyle::kHairline_InitStyle);
-          if (!pe->filterPath(&filteredPath, filteredPath, &rec, nullptr)) {
+          SkPathBuilder filteredBuilder;
+          if (!pe->filterPath(&filteredBuilder, filteredPath, &rec)) {
             throw std::runtime_error(
                 "Failed trimming path with parameters start: " +
                 std::to_string(start) + ", end: " + std::to_string(end));
           }
-          filteredPath.swap(filteredPath);
+          filteredPath = filteredBuilder.detach();
         } else {
           throw std::runtime_error(
               "Failed trimming path with parameters start: " +

package/cpp/rnskia/RNDawnContext.h

@@ -188,6 +188,27 @@ public:
   // Get the wgpu::Device for WebGPU bindings
   wgpu::Device getWGPUDevice() { return backendContext.fDevice; }
 
+  // Create a secondary Dawn device from the same adapter.
+  // Has its own command queue and does NOT enable ImplicitDeviceSynchronization,
+  // so it won't contend with the primary rendering device's mutex.
+  // Safe for concurrent GPU work (e.g. ML inference) alongside Skia rendering.
+  wgpu::Device createSecondaryDevice() {
+    auto adapter = DawnUtils::getMatchedAdapter(instance.get());
+
+    std::vector<wgpu::FeatureName> features = {
+        wgpu::FeatureName::BufferMapExtendedUsages,
+#ifdef __APPLE__
+        wgpu::FeatureName::SharedTextureMemoryIOSurface,
+        wgpu::FeatureName::DawnMultiPlanarFormats,
+        // Note: SharedFenceMTLSharedEvent intentionally NOT enabled — it causes
+        // EndAccess to encode fence signals that crash with "uncommitted encoder".
+        // IOSurface data is already written by the camera before we read it.
+#endif
+    };
+
+    return DawnUtils::requestDevice(adapter, features, false);
+  }
+
   // Create an SkImage from a WebGPU texture
   // The texture must have TextureBinding usage
   sk_sp<SkImage> MakeImageFromTexture(wgpu::Texture texture, int width,

package/cpp/rnskia/RNDawnUtils.h

@@ -21,35 +21,21 @@ static const wgpu::TextureFormat PreferredTextureFormat =
     wgpu::TextureFormat::RGBA8Unorm;
 #endif
 
-inline skgpu::graphite::DawnBackendContext
-createDawnBackendContext(dawn::native::Instance *instance) {
-
-  auto useTintIR = false;
-  static constexpr const char *kToggles[] = {
-#if !defined(SK_DEBUG)
-      "skip_validation",
-#endif
-      "disable_lazy_clear_for_mapped_at_creation_buffer",
-      "allow_unsafe_apis",
-      "use_user_defined_labels_in_backend",
-      "disable_robustness",
-      "use_tint_ir",
-  };
-  wgpu::DawnTogglesDescriptor togglesDesc;
-  togglesDesc.enabledToggleCount = std::size(kToggles) - (useTintIR ? 0 : 1);
-  togglesDesc.enabledToggles = kToggles;
-
-  dawn::native::Adapter matchedAdaptor;
-
-  wgpu::RequestAdapterOptions options;
+// Find the best matching GPU adapter for the current platform.
+// Sorts by adapter type (DiscreteGPU > IntegratedGPU > CPU) and selects the
+// first adapter matching the platform backend (Metal on Apple, Vulkan on
+// Android).
+inline dawn::native::Adapter
+getMatchedAdapter(dawn::native::Instance *instance) {
 #ifdef __APPLE__
   constexpr auto kDefaultBackendType = wgpu::BackendType::Metal;
 #elif __ANDROID__
   constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
 #endif
+
+  wgpu::RequestAdapterOptions options;
   options.backendType = kDefaultBackendType;
   options.featureLevel = wgpu::FeatureLevel::Core;
-  options.nextInChain = &togglesDesc;
 
   std::vector<dawn::native::Adapter> adapters =
       instance->EnumerateAdapters(&options);
@@ -57,8 +43,6 @@ createDawnBackendContext(dawn::native::Instance *instance) {
     throw std::runtime_error("No matching adapter found");
   }
 
-  // Sort adapters by adapterType(DiscreteGPU, IntegratedGPU, CPU) and
-  // backendType(Metal, Vulkan, OpenGL, OpenGLES, WebGPU).
   std::sort(adapters.begin(), adapters.end(),
             [](dawn::native::Adapter a, dawn::native::Adapter b) {
               wgpu::Adapter wgpuA = a.Get();
@@ -76,16 +60,93 @@ createDawnBackendContext(dawn::native::Instance *instance) {
     wgpu::AdapterInfo props;
     wgpuAdapter.GetInfo(&props);
     if (kDefaultBackendType == props.backendType) {
-      matchedAdaptor = adapter;
-      break;
+      return adapter;
     }
   }
 
-  if (!matchedAdaptor) {
-    throw std::runtime_error("No matching adapter found");
+  throw std::runtime_error("No matching adapter found");
+}
+
+// Create a Dawn device from the given adapter with the requested features.
+// Features not supported by the adapter are silently skipped.
+// Set fatalOnDeviceLost=true for primary rendering devices (SK_ABORT on loss),
+// false for secondary/compute devices (log only).
+inline wgpu::Device
+requestDevice(dawn::native::Adapter &nativeAdapter,
+              const std::vector<wgpu::FeatureName> &requestedFeatures,
+              bool fatalOnDeviceLost = true) {
+  wgpu::Adapter adapter = nativeAdapter.Get();
+
+  // Filter to only features the adapter supports
+  std::vector<wgpu::FeatureName> features;
+  for (auto feature : requestedFeatures) {
+    if (adapter.HasFeature(feature)) {
+      features.push_back(feature);
+    }
   }
 
-  wgpu::Adapter adapter = matchedAdaptor.Get();
+  static constexpr const char *kToggles[] = {
+#if !defined(SK_DEBUG)
+      "skip_validation",
+#endif
+      "disable_lazy_clear_for_mapped_at_creation_buffer",
+      "allow_unsafe_apis",
+      "use_user_defined_labels_in_backend",
+      "disable_robustness",
+  };
+  wgpu::DawnTogglesDescriptor togglesDesc;
+  togglesDesc.enabledToggleCount = std::size(kToggles);
+  togglesDesc.enabledToggles = kToggles;
+
+  wgpu::DeviceDescriptor desc;
+  desc.requiredFeatureCount = features.size();
+  desc.requiredFeatures = features.data();
+  desc.nextInChain = &togglesDesc;
+
+  if (fatalOnDeviceLost) {
+    desc.SetDeviceLostCallback(
+        wgpu::CallbackMode::AllowSpontaneous,
+        [](const wgpu::Device &, wgpu::DeviceLostReason reason,
+           wgpu::StringView message) {
+          if (reason != wgpu::DeviceLostReason::Destroyed) {
+            SK_ABORT("Device lost: %.*s\n",
+                     static_cast<int>(message.length), message.data);
+          }
+        });
+    desc.SetUncapturedErrorCallback(
+        [](const wgpu::Device &, wgpu::ErrorType,
+           wgpu::StringView message) {
+          SkDebugf("Device error: %.*s\n",
+                   static_cast<int>(message.length), message.data);
+        });
+  } else {
+    desc.SetDeviceLostCallback(
+        wgpu::CallbackMode::AllowSpontaneous,
+        [](const wgpu::Device &, wgpu::DeviceLostReason reason,
+           wgpu::StringView message) {
+          if (reason != wgpu::DeviceLostReason::Destroyed) {
+            RNSkia::RNSkLogger::logToConsole(
+                "Device lost: %.*s",
+                static_cast<int>(message.length), message.data);
+          }
+        });
+    desc.SetUncapturedErrorCallback(
+        [](const wgpu::Device &, wgpu::ErrorType,
+           wgpu::StringView message) {
+          RNSkia::RNSkLogger::logToConsole(
+              "Device error: %.*s",
+              static_cast<int>(message.length), message.data);
+        });
+  }
+
+  return wgpu::Device::Acquire(nativeAdapter.CreateDevice(&desc));
+}
+
+inline skgpu::graphite::DawnBackendContext
+createDawnBackendContext(dawn::native::Instance *instance) {
+
+  auto matchedAdapter = getMatchedAdapter(instance);
+  wgpu::Adapter adapter = matchedAdapter.Get();
 
   // Log selected adapter info
   wgpu::AdapterInfo adapterInfo;
@@ -130,93 +191,34 @@ createDawnBackendContext(dawn::native::Instance *instance) {
       "Selected Dawn adapter - Backend: %s, Device: %s, Description: %s",
       backendName.c_str(), deviceName.c_str(), description.c_str());
 
-  std::vector<wgpu::FeatureName> features;
-  if (adapter.HasFeature(wgpu::FeatureName::MSAARenderToSingleSampled)) {
-    features.push_back(wgpu::FeatureName::MSAARenderToSingleSampled);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::TransientAttachments)) {
-    features.push_back(wgpu::FeatureName::TransientAttachments);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::Unorm16TextureFormats)) {
-    features.push_back(wgpu::FeatureName::Unorm16TextureFormats);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::DualSourceBlending)) {
-    features.push_back(wgpu::FeatureName::DualSourceBlending);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::FramebufferFetch)) {
-    features.push_back(wgpu::FeatureName::FramebufferFetch);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::BufferMapExtendedUsages)) {
-    features.push_back(wgpu::FeatureName::BufferMapExtendedUsages);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionETC2)) {
-    features.push_back(wgpu::FeatureName::TextureCompressionETC2);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionBC)) {
-    features.push_back(wgpu::FeatureName::TextureCompressionBC);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::R8UnormStorage)) {
-    features.push_back(wgpu::FeatureName::R8UnormStorage);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::DawnLoadResolveTexture)) {
-    features.push_back(wgpu::FeatureName::DawnLoadResolveTexture);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::DawnPartialLoadResolveTexture)) {
-    features.push_back(wgpu::FeatureName::DawnPartialLoadResolveTexture);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::TimestampQuery)) {
-    features.push_back(wgpu::FeatureName::TimestampQuery);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::DawnTexelCopyBufferRowAlignment)) {
-    features.push_back(wgpu::FeatureName::DawnTexelCopyBufferRowAlignment);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::ImplicitDeviceSynchronization)) {
-    features.push_back(wgpu::FeatureName::ImplicitDeviceSynchronization);
-  }
+  // Primary device features — request everything Skia/Graphite can use
+  std::vector<wgpu::FeatureName> features = {
+      wgpu::FeatureName::MSAARenderToSingleSampled,
+      wgpu::FeatureName::TransientAttachments,
+      wgpu::FeatureName::Unorm16TextureFormats,
+      wgpu::FeatureName::DualSourceBlending,
+      wgpu::FeatureName::FramebufferFetch,
+      wgpu::FeatureName::BufferMapExtendedUsages,
+      wgpu::FeatureName::TextureCompressionETC2,
+      wgpu::FeatureName::TextureCompressionBC,
+      wgpu::FeatureName::R8UnormStorage,
+      wgpu::FeatureName::DawnLoadResolveTexture,
+      wgpu::FeatureName::DawnPartialLoadResolveTexture,
+      wgpu::FeatureName::TimestampQuery,
+      wgpu::FeatureName::DawnTexelCopyBufferRowAlignment,
+      wgpu::FeatureName::ImplicitDeviceSynchronization,
 #ifdef __APPLE__
-  if (adapter.HasFeature(wgpu::FeatureName::SharedTextureMemoryIOSurface)) {
-    features.push_back(wgpu::FeatureName::SharedTextureMemoryIOSurface);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::DawnMultiPlanarFormats)) {
-    features.push_back(wgpu::FeatureName::DawnMultiPlanarFormats);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::MultiPlanarFormatP010)) {
-    features.push_back(wgpu::FeatureName::MultiPlanarFormatP010);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::MultiPlanarFormatP210)) {
-    features.push_back(wgpu::FeatureName::MultiPlanarFormatP210);
-  }
-  if (adapter.HasFeature(wgpu::FeatureName::MultiPlanarFormatExtendedUsages)) {
-    features.push_back(wgpu::FeatureName::MultiPlanarFormatExtendedUsages);
-  }
+      wgpu::FeatureName::SharedTextureMemoryIOSurface,
+      wgpu::FeatureName::DawnMultiPlanarFormats,
+      wgpu::FeatureName::MultiPlanarFormatP010,
+      wgpu::FeatureName::MultiPlanarFormatP210,
+      wgpu::FeatureName::MultiPlanarFormatExtendedUsages,
 #else
-  if (adapter.HasFeature(
-          wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer)) {
-    features.push_back(wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer);
-  }
+      wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer,
 #endif
+  };
 
-  wgpu::DeviceDescriptor desc;
-  desc.requiredFeatureCount = features.size();
-  desc.requiredFeatures = features.data();
-  desc.nextInChain = &togglesDesc;
-  desc.SetDeviceLostCallback(
-      wgpu::CallbackMode::AllowSpontaneous,
-      [](const wgpu::Device &, wgpu::DeviceLostReason reason,
-         wgpu::StringView message) {
-        if (reason != wgpu::DeviceLostReason::Destroyed) {
-          SK_ABORT("Device lost: %.*s\n", static_cast<int>(message.length),
-                   message.data);
-        }
-      });
-  desc.SetUncapturedErrorCallback(
-      [](const wgpu::Device &, wgpu::ErrorType, wgpu::StringView message) {
-        SkDebugf("Device error: %.*s\n", static_cast<int>(message.length),
-                 message.data);
-      });
-
-  wgpu::Device device =
-      wgpu::Device::Acquire(matchedAdaptor.CreateDevice(&desc));
+  wgpu::Device device = requestDevice(matchedAdapter, features, true);
   SkASSERT(device);
 
   skgpu::graphite::DawnBackendContext backendContext;
@@ -227,4 +229,4 @@ createDawnBackendContext(dawn::native::Instance *instance) {
   return backendContext;
 }
 
-} // namespace DawnUtils
+} // namespace DawnUtils

package/lib/commonjs/animation/functions/interpolatePaths.d.ts

@@ -16,4 +16,4 @@ import type { ExtrapolationType } from "./interpolate";
  * path2.lineTo(0, 100);
  * const path = interpolatePath(0.5, [0, 1], [path1, path2]);
  */
-export declare const interpolatePaths: (value: number, input: number[], outputRange: SkPath[], options?: ExtrapolationType, output?: SkPath) => SkPath;
+export declare const interpolatePaths: (value: number, input: number[], outputRange: SkPath[], options?: ExtrapolationType, _output?: SkPath) => SkPath;