@shopify/react-native-skia 2.5.5 → 2.6.1

package/cpp/api/recorder/Shaders.h

@@ -5,6 +5,7 @@
 #include <variant>
 
 #include <include/core/SkSamplingOptions.h>
+#include <include/effects/SkGradient.h>
 
 #include "Command.h"
 #include "Convertor.h"
@@ -250,11 +251,24 @@ public:
 
     SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
     const SkPoint pts[2] = {props.start, props.end};
-    auto shader = SkGradientShader::MakeLinear(
-        pts, props.colors.data(),
-        props.positions ? props.positions->data() : nullptr,
-        props.colors.size(), props.mode.value_or(SkTileMode::kClamp),
-        props.flags.value_or(0), &m3);
+
+    // Convert SkColor to SkColor4f
+    std::vector<SkColor4f> colors4f;
+    colors4f.reserve(props.colors.size());
+    for (const auto &c : props.colors) {
+      colors4f.push_back(SkColor4f::FromColor(c));
+    }
+
+    auto tileMode = props.mode.value_or(SkTileMode::kClamp);
+    SkGradient::Colors gradColors(
+        SkSpan(colors4f),
+        props.positions ? SkSpan<const float>(props.positions->data(),
+                                              props.positions->size())
+                        : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(
+                                    props.flags.value_or(0)));
+    auto shader = SkShaders::LinearGradient(pts, grad, &m3);
     ctx->shaders.push_back(shader);
   }
 };
@@ -293,11 +307,25 @@ public:
     }
 
     SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
-    auto shader = SkGradientShader::MakeRadial(
-        props.center, props.radius, props.colors.data(),
-        props.positions ? props.positions->data() : nullptr,
-        props.colors.size(), props.mode.value_or(SkTileMode::kClamp),
-        props.flags.value_or(0), &m3);
+
+    // Convert SkColor to SkColor4f
+    std::vector<SkColor4f> colors4f;
+    colors4f.reserve(props.colors.size());
+    for (const auto &c : props.colors) {
+      colors4f.push_back(SkColor4f::FromColor(c));
+    }
+
+    auto tileMode = props.mode.value_or(SkTileMode::kClamp);
+    SkGradient::Colors gradColors(
+        SkSpan(colors4f),
+        props.positions ? SkSpan<const float>(props.positions->data(),
+                                              props.positions->size())
+                        : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(
+                                    props.flags.value_or(0)));
+    auto shader =
+        SkShaders::RadialGradient(props.center, props.radius, grad, &m3);
     ctx->shaders.push_back(shader);
   }
 };
@@ -338,12 +366,26 @@ public:
     }
 
     SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
-    auto shader = SkGradientShader::MakeSweep(
-        props.center.x(), props.center.y(), props.colors.data(),
-        props.positions ? props.positions->data() : nullptr,
-        props.colors.size(), props.mode.value_or(SkTileMode::kClamp),
-        props.start.value_or(0), props.end.value_or(360),
-        props.flags.value_or(0), &m3);
+
+    // Convert SkColor to SkColor4f
+    std::vector<SkColor4f> colors4f;
+    colors4f.reserve(props.colors.size());
+    for (const auto &c : props.colors) {
+      colors4f.push_back(SkColor4f::FromColor(c));
+    }
+
+    auto tileMode = props.mode.value_or(SkTileMode::kClamp);
+    SkGradient::Colors gradColors(
+        SkSpan(colors4f),
+        props.positions ? SkSpan<const float>(props.positions->data(),
+                                              props.positions->size())
+                        : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(
+                                    props.flags.value_or(0)));
+    auto shader =
+        SkShaders::SweepGradient(props.center, props.start.value_or(0),
+                                 props.end.value_or(360), grad, &m3);
     ctx->shaders.push_back(shader);
   }
 };
@@ -387,12 +429,25 @@ public:
     }
 
     SkMatrix m3 = processTransform(props.matrix, props.transform, props.origin);
-    auto shader = SkGradientShader::MakeTwoPointConical(
-        props.start, props.startRadius, props.end, props.endRadius,
-        props.colors.data(),
-        props.positions ? props.positions->data() : nullptr,
-        props.colors.size(), props.mode.value_or(SkTileMode::kClamp),
-        props.flags.value_or(0), &m3);
+
+    // Convert SkColor to SkColor4f
+    std::vector<SkColor4f> colors4f;
+    colors4f.reserve(props.colors.size());
+    for (const auto &c : props.colors) {
+      colors4f.push_back(SkColor4f::FromColor(c));
+    }
+
+    auto tileMode = props.mode.value_or(SkTileMode::kClamp);
+    SkGradient::Colors gradColors(
+        SkSpan(colors4f),
+        props.positions ? SkSpan<const float>(props.positions->data(),
+                                              props.positions->size())
+                        : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(
+                                    props.flags.value_or(0)));
+    auto shader = SkShaders::TwoPointConicalGradient(
+        props.start, props.startRadius, props.end, props.endRadius, grad, &m3);
     ctx->shaders.push_back(shader);
   }
 };

package/cpp/jsi2/JSIConverter.h

@@ -241,7 +241,7 @@ template <> struct JSIConverter<rnwgpu::async::AsyncTaskHandle> {
 // jsi::Function <> Function
 template <> struct JSIConverter<jsi::Function> {
   static jsi::Function fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
-                                bool outOfBound) {
+                               bool outOfBound) {
     return arg.asObject(runtime).asFunction(runtime);
   }
   static jsi::Value toJSI(jsi::Runtime &runtime, jsi::Function &&arg) {

package/cpp/rnskia/RNDawnContext.h

@@ -114,7 +114,6 @@ public:
     wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc;
     auto ahb = (AHardwareBuffer *)buffer;
     platformDesc.handle = ahb;
-    platformDesc.useExternalFormat = true;
     AHardwareBuffer_Desc adesc;
     AHardwareBuffer_describe(ahb, &adesc);
     int width = adesc.width;
@@ -164,15 +163,14 @@ public:
 
   // Create offscreen surface
   sk_sp<SkSurface> MakeOffscreen(int width, int height,
-                                  bool useP3ColorSpace = false) {
+                                 bool useP3ColorSpace = false) {
     sk_sp<SkColorSpace> colorSpace =
-        useP3ColorSpace
-            ? SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB,
-                                    SkNamedGamut::kDisplayP3)
-            : nullptr;
-    SkImageInfo info = SkImageInfo::Make(
-        width, height, DawnUtils::PreferedColorType, kPremul_SkAlphaType,
-        colorSpace);
+        useP3ColorSpace ? SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB,
+                                                SkNamedGamut::kDisplayP3)
+                        : nullptr;
+    SkImageInfo info =
+        SkImageInfo::Make(width, height, DawnUtils::PreferedColorType,
+                          kPremul_SkAlphaType, colorSpace);
     sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(getRecorder(), info);
 
     if (!surface) {
@@ -188,6 +186,28 @@ 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,90 @@ 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 +188,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::BGRA8UnormStorage,
+      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 +226,4 @@ createDawnBackendContext(dawn::native::Instance *instance) {
   return backendContext;
 }
 
-} // namespace DawnUtils
+} // namespace DawnUtils

package/cpp/rnskia/RNDawnWindowContext.h

@@ -38,7 +38,7 @@ public:
       return nullptr;
     }
     skgpu::graphite::DawnTextureInfo info(
-        /*sampleCount=*/1, skgpu::Mipmapped::kNo,
+        skgpu::graphite::SampleCount::k1, skgpu::Mipmapped::kNo,
         DawnUtils::PreferredTextureFormat, texture.GetUsage(),
         wgpu::TextureAspect::All);
     auto backendTex = skgpu::graphite::BackendTextures::MakeDawn(texture.Get());

package/cpp/rnskia/RNSkManager.cpp

@@ -106,13 +106,14 @@ void RNSkManager::installBindings() {
                                    rnwgpu::GPUMapMode::create(*_jsRuntime));
   _jsRuntime->global().setProperty(*_jsRuntime, "GPUShaderStage",
                                    rnwgpu::GPUShaderStage::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUTextureUsage",
-                                   rnwgpu::GPUTextureUsage::create(*_jsRuntime));
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "GPUTextureUsage",
+      rnwgpu::GPUTextureUsage::create(*_jsRuntime));
 
   // Install RNWebGPU global object for WebGPU Canvas support
   auto rnWebGPU = std::make_shared<rnwgpu::RNWebGPU>(gpu, nullptr);
-  _jsRuntime->global().setProperty(*_jsRuntime, "RNWebGPU",
-                                   rnwgpu::RNWebGPU::create(*_jsRuntime, rnWebGPU));
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "RNWebGPU", rnwgpu::RNWebGPU::create(*_jsRuntime, rnWebGPU));
 #endif
 }
 } // namespace RNSkia

package/cpp/rnskia/RNSkPlatformContext.h

@@ -93,8 +93,8 @@ public:
    * @param useP3ColorSpace If true, surface will use Display P3 color space
    * @return sk_sp<SkSurface>
    */
-  virtual sk_sp<SkSurface> makeOffscreenSurface(int width, int height,
-                                                 bool useP3ColorSpace = false) = 0;
+  virtual sk_sp<SkSurface>
+  makeOffscreenSurface(int width, int height, bool useP3ColorSpace = false) = 0;
 
   virtual std::shared_ptr<WindowContext>
   makeContextFromNativeSurface(void *surface, int width, int height) = 0;

package/cpp/rnwgpu/api/GPU.cpp

@@ -124,6 +124,27 @@ std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
     case wgpu::WGSLLanguageFeatureName::ChromiumPrint:
       name = "chromium_print";
       break;
+    case wgpu::WGSLLanguageFeatureName::TextureAndSamplerLet:
+      name = "texture_and_sampler_let";
+      break;
+    case wgpu::WGSLLanguageFeatureName::SubgroupUniformity:
+      name = "subgroup_uniformity";
+      break;
+    case wgpu::WGSLLanguageFeatureName::TextureFormatsTier1:
+      name = "texture_formats_tier1";
+      break;
+    case wgpu::WGSLLanguageFeatureName::BufferView:
+      name = "buffer_view";
+      break;
+    case wgpu::WGSLLanguageFeatureName::FilteringParameters:
+      name = "filtering_parameters";
+      break;
+    case wgpu::WGSLLanguageFeatureName::SwizzleAssignment:
+      name = "swizzle_assignment";
+      break;
+    case wgpu::WGSLLanguageFeatureName::LinearIndexing:
+      name = "linear_indexing";
+      break;
     }
     result.insert(name);
   }

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -47,7 +47,7 @@ std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
     _surfaceInfo->reconfigure(width, height);
   }
   auto texture = _surfaceInfo->getCurrentTexture();
-  return std::make_shared<GPUTexture>(texture, "");
+  return std::make_shared<GPUTexture>(texture, "", false);
 }
 
 void GPUCanvasContext::present() {

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -10,10 +10,10 @@
 
 #include "jsi2/NativeObject.h"
 
-#include "rnwgpu/Canvas.h"
 #include "GPU.h"
-#include "descriptors/GPUCanvasConfiguration.h"
 #include "GPUTexture.h"
+#include "descriptors/GPUCanvasConfiguration.h"
+#include "rnwgpu/Canvas.h"
 #include "rnwgpu/SurfaceRegistry.h"
 
 namespace rnwgpu {

package/cpp/rnwgpu/api/GPUFeatures.h

@@ -89,9 +89,6 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::Unorm16TextureFormats:
     *outUnion = "unorm16-texture-formats";
     break;
-  case wgpu::FeatureName::Snorm16TextureFormats:
-    *outUnion = "snorm16-texture-formats";
-    break;
   case wgpu::FeatureName::MultiPlanarFormatExtendedUsages:
     *outUnion = "multi-planar-format-extended-usages";
     break;
@@ -122,18 +119,12 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::AdapterPropertiesVk:
     *outUnion = "adapter-properties-vk";
     break;
-  case wgpu::FeatureName::R8UnormStorage:
-    *outUnion = "r8unorm-storage";
-    break;
   case wgpu::FeatureName::DawnFormatCapabilities:
     *outUnion = "format-capabilities";
     break;
   case wgpu::FeatureName::DawnDrmFormatCapabilities:
     *outUnion = "drm-format-capabilities";
     break;
-  case wgpu::FeatureName::Norm16TextureFormats:
-    *outUnion = "norm16-texture-formats";
-    break;
   case wgpu::FeatureName::MultiPlanarFormatNv16:
     *outUnion = "multi-planar-format-nv16";
     break;

package/cpp/rnwgpu/api/GPUTexture.h

@@ -21,8 +21,10 @@ class GPUTexture : public NativeObject<GPUTexture> {
 public:
   static constexpr const char *CLASS_NAME = "GPUTexture";
 
-  explicit GPUTexture(wgpu::Texture instance, std::string label)
-      : NativeObject(CLASS_NAME), _instance(instance), _label(label) {}
+  explicit GPUTexture(wgpu::Texture instance, std::string label,
+                      bool reportsMemoryPressure = true)
+      : NativeObject(CLASS_NAME), _instance(instance), _label(label),
+        _reportsMemoryPressure(reportsMemoryPressure) {}
 
 public:
   std::string getBrand() { return CLASS_NAME; }
@@ -68,6 +70,9 @@ public:
   inline const wgpu::Texture get() { return _instance; }
 
   size_t getMemoryPressure() override {
+    if (!_reportsMemoryPressure) {
+      return sizeof(GPUTexture);
+    }
     // Calculate approximate memory usage based on texture properties
     uint32_t width = getWidth();
     uint32_t height = getHeight();
@@ -85,6 +90,7 @@ public:
     case wgpu::TextureFormat::R8Snorm:
     case wgpu::TextureFormat::R8Uint:
     case wgpu::TextureFormat::R8Sint:
+    case wgpu::TextureFormat::Stencil8:
       bytesPerPixel = 1;
       break;
     case wgpu::TextureFormat::R16Uint:
@@ -94,6 +100,7 @@ public:
     case wgpu::TextureFormat::RG8Snorm:
     case wgpu::TextureFormat::RG8Uint:
     case wgpu::TextureFormat::RG8Sint:
+    case wgpu::TextureFormat::Depth16Unorm:
       bytesPerPixel = 2;
       break;
     case wgpu::TextureFormat::RGBA8Unorm:
@@ -110,6 +117,9 @@ public:
     case wgpu::TextureFormat::RG16Uint:
     case wgpu::TextureFormat::RG16Sint:
     case wgpu::TextureFormat::RG16Float:
+    case wgpu::TextureFormat::Depth24Plus:
+    case wgpu::TextureFormat::Depth24PlusStencil8:
+    case wgpu::TextureFormat::Depth32Float:
       bytesPerPixel = 4;
       break;
     case wgpu::TextureFormat::RG32Float:
@@ -118,6 +128,7 @@ public:
     case wgpu::TextureFormat::RGBA16Uint:
     case wgpu::TextureFormat::RGBA16Sint:
     case wgpu::TextureFormat::RGBA16Float:
+    case wgpu::TextureFormat::Depth32FloatStencil8:
       bytesPerPixel = 8;
       break;
     case wgpu::TextureFormat::RGBA32Float:
@@ -145,6 +156,7 @@ public:
 private:
   wgpu::Texture _instance;
   std::string _label;
+  bool _reportsMemoryPressure = true;
 };
 
 } // namespace rnwgpu