@shopify/react-native-skia 2.6.0 → 2.6.1

package/cpp/api/JsiSkShaderFactory.h

@@ -44,8 +44,9 @@ SkTileMode getTileMode(const jsi::Value *values, int i, size_t size) {
   return static_cast<SkTileMode>(values[i].asNumber());
 }
 
-std::vector<SkColor> getColors(jsi::Runtime &runtime, const jsi::Value &value) {
-  std::vector<SkColor> colors;
+std::vector<SkColor4f> getColors(jsi::Runtime &runtime,
+                                 const jsi::Value &value) {
+  std::vector<SkColor4f> colors;
   if (!value.isNull()) {
     auto jsiColors = value.asObject(runtime).asArray(runtime);
     auto size = jsiColors.size(runtime);
@@ -53,7 +54,7 @@ std::vector<SkColor> getColors(jsi::Runtime &runtime, const jsi::Value &value) {
     for (int i = 0; i < size; i++) {
       SkColor color =
           JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
-      colors.push_back(color);
+      colors.push_back(SkColor4f::FromColor(color));
     }
   }
   return colors;
@@ -83,7 +84,7 @@ public:
         *JsiSkPoint::fromValue(runtime, arguments[1].asObject(runtime)).get();
     SkPoint pts[] = {p1, p2};
 
-    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
     auto colorsSize = colors.size();
     if (colorsSize < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
@@ -97,9 +98,15 @@ public:
     auto flag = getFlag(arguments, 6, count);
     auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
 
-    sk_sp<SkShader> gradient = SkGradientShader::MakeLinear(
-        pts, colors.data(), !positions.empty() ? positions.data() : nullptr,
-        static_cast<int>(colorsSize), tileMode, flag, localMatrix);
+    SkGradient::Colors gradColors(
+        SkSpan(colors),
+        !positions.empty()
+            ? SkSpan<const float>(positions.data(), positions.size())
+            : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    sk_sp<SkShader> gradient =
+        SkShaders::LinearGradient(pts, grad, localMatrix);
     auto shader =
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
@@ -111,7 +118,7 @@ public:
         *JsiSkPoint::fromValue(runtime, arguments[0].asObject(runtime)).get();
     auto r = arguments[1].asNumber();
 
-    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
     auto colorsSize = colors.size();
     if (colorsSize < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
@@ -125,10 +132,15 @@ public:
     auto flag = getFlag(arguments, 6, count);
     auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
 
-    sk_sp<SkShader> gradient = SkGradientShader::MakeRadial(
-        center, r, colors.data(),
-        !positions.empty() ? positions.data() : nullptr,
-        static_cast<int>(colorsSize), tileMode, flag, localMatrix);
+    SkGradient::Colors gradColors(
+        SkSpan(colors),
+        !positions.empty()
+            ? SkSpan<const float>(positions.data(), positions.size())
+            : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    sk_sp<SkShader> gradient =
+        SkShaders::RadialGradient(center, r, grad, localMatrix);
     auto shader =
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
@@ -138,7 +150,7 @@ public:
   JSI_HOST_FUNCTION(MakeSweepGradient) {
     auto x = arguments[0].asNumber();
     auto y = arguments[1].asNumber();
-    std::vector<SkColor> colors = getColors(runtime, arguments[2]);
+    std::vector<SkColor4f> colors = getColors(runtime, arguments[2]);
     auto colorsSize = colors.size();
     if (colorsSize < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
@@ -151,15 +163,22 @@ public:
     auto tileMode = getTileMode(arguments, 4, count);
     auto localMatrix = getLocalMatrix(runtime, arguments, 5, count);
     auto flag = getFlag(arguments, 6, count);
-    auto startAngle =
-        (count < 8 || arguments[7].isUndefined()) ? 0 : arguments[7].asNumber();
+    auto startAngle = (count < 8 || arguments[7].isUndefined())
+                          ? 0.0f
+                          : static_cast<float>(arguments[7].asNumber());
     auto endAngle = (count < 9 || arguments[8].isUndefined())
-                        ? 360
-                        : arguments[8].asNumber();
-    sk_sp<SkShader> gradient = SkGradientShader::MakeSweep(
-        x, y, colors.data(), !positions.empty() ? positions.data() : nullptr,
-        static_cast<int>(colorsSize), tileMode, startAngle, endAngle, flag,
-        localMatrix);
+                        ? 360.0f
+                        : static_cast<float>(arguments[8].asNumber());
+
+    SkGradient::Colors gradColors(
+        SkSpan(colors),
+        !positions.empty()
+            ? SkSpan<const float>(positions.data(), positions.size())
+            : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    sk_sp<SkShader> gradient = SkShaders::SweepGradient(
+        SkPoint::Make(x, y), startAngle, endAngle, grad, localMatrix);
     auto shader =
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient));
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, shader,
@@ -175,7 +194,7 @@ public:
         *JsiSkPoint::fromValue(runtime, arguments[2].asObject(runtime)).get();
     auto endRadius = arguments[3].asNumber();
 
-    std::vector<SkColor> colors = getColors(runtime, arguments[4]);
+    std::vector<SkColor4f> colors = getColors(runtime, arguments[4]);
     auto colorsSize = colors.size();
     if (colorsSize < 2) {
       throw std::invalid_argument("colors must have at least 2 colors");
@@ -189,10 +208,15 @@ public:
     auto localMatrix = getLocalMatrix(runtime, arguments, 7, count);
     auto flag = getFlag(arguments, 8, count);
 
-    sk_sp<SkShader> gradient = SkGradientShader::MakeTwoPointConical(
-        start, startRadius, end, endRadius, colors.data(),
-        !positions.empty() ? positions.data() : nullptr,
-        static_cast<int>(colorsSize), tileMode, flag, localMatrix);
+    SkGradient::Colors gradColors(
+        SkSpan(colors),
+        !positions.empty()
+            ? SkSpan<const float>(positions.data(), positions.size())
+            : SkSpan<const float>(),
+        tileMode);
+    SkGradient grad(gradColors, SkGradient::Interpolation::FromFlags(flag));
+    sk_sp<SkShader> gradient = SkShaders::TwoPointConicalGradient(
+        start, startRadius, end, endRadius, grad, localMatrix);
 
     auto shader =
         std::make_shared<JsiSkShader>(getContext(), std::move(gradient));

package/cpp/api/JsiSkSurfaceFactory.h

@@ -51,7 +51,8 @@ public:
       }
     }
     auto context = getContext();
-    auto surface = context->makeOffscreenSurface(width, height, useP3ColorSpace);
+    auto surface =
+        context->makeOffscreenSurface(width, height, useP3ColorSpace);
     if (surface == nullptr) {
       return jsi::Value::null();
     }

package/cpp/api/recorder/Drawings.h

@@ -166,14 +166,11 @@ public:
           strokePaint.setStrokeMiter(stroke.miter_limit.value());
         }
 
-        float precision = stroke.precision.value_or(1.0f);
-
-        auto strokedPath = std::make_shared<SkPath>();
-        if (!skpathutils::FillPathWithPaint(*p, strokePaint, strokedPath.get(),
-                                            nullptr, precision)) {
+        SkPathBuilder resultBuilder;
+        if (!skpathutils::FillPathWithPaint(*p, strokePaint, &resultBuilder)) {
           throw std::runtime_error("Failed to apply stroke to path");
         }
-        pathToUse = std::const_pointer_cast<const SkPath>(strokedPath);
+        pathToUse = std::make_shared<const SkPath>(resultBuilder.snapshot());
       } else {
         pathToUse = std::const_pointer_cast<const SkPath>(p);
       }
@@ -939,7 +936,8 @@ public:
     convertProperty(runtime, object, "sprites", props.sprites, variables);
     convertProperty(runtime, object, "transforms", props.transforms, variables);
     convertProperty(runtime, object, "colors", props.colors, variables);
-    convertProperty(runtime, object, "colorBlendMode", props.blendMode, variables);
+    convertProperty(runtime, object, "colorBlendMode", props.blendMode,
+                    variables);
     convertProperty(runtime, object, "sampling", props.sampling, variables);
   }
 

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) {
@@ -189,9 +187,10 @@ public:
   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.
+  // 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());
 
@@ -200,9 +199,9 @@ public:
 #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.
+    // 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
     };
 

package/cpp/rnskia/RNDawnUtils.h

@@ -109,15 +109,14 @@ requestDevice(dawn::native::Adapter &nativeAdapter,
         [](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);
+            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);
+        [](const wgpu::Device &, wgpu::ErrorType, wgpu::StringView message) {
+          SkDebugf("Device error: %.*s\n", static_cast<int>(message.length),
+                   message.data);
         });
   } else {
     desc.SetDeviceLostCallback(
@@ -125,18 +124,16 @@ requestDevice(dawn::native::Adapter &nativeAdapter,
         [](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);
+            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);
-        });
+    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));
@@ -201,7 +198,7 @@ createDawnBackendContext(dawn::native::Instance *instance) {
       wgpu::FeatureName::BufferMapExtendedUsages,
       wgpu::FeatureName::TextureCompressionETC2,
       wgpu::FeatureName::TextureCompressionBC,
-      wgpu::FeatureName::R8UnormStorage,
+      wgpu::FeatureName::BGRA8UnormStorage,
       wgpu::FeatureName::DawnLoadResolveTexture,
       wgpu::FeatureName::DawnPartialLoadResolveTexture,
       wgpu::FeatureName::TimestampQuery,

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

package/cpp/rnwgpu/api/GPUUncapturedErrorEvent.h

@@ -15,10 +15,9 @@ namespace rnwgpu {
 
 namespace jsi = facebook::jsi;
 
-using GPUErrorVariant =
-    std::variant<std::shared_ptr<GPUValidationError>,
-                 std::shared_ptr<GPUOutOfMemoryError>,
-                 std::shared_ptr<GPUInternalError>>;
+using GPUErrorVariant = std::variant<std::shared_ptr<GPUValidationError>,
+                                     std::shared_ptr<GPUOutOfMemoryError>,
+                                     std::shared_ptr<GPUInternalError>>;
 
 class GPUUncapturedErrorEvent : public NativeObject<GPUUncapturedErrorEvent> {
 public:

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -5,9 +5,9 @@
 
 #include "jsi2/NativeObject.h"
 
-#include "rnwgpu/Canvas.h"
 #include "GPU.h"
 #include "GPUCanvasContext.h"
+#include "rnwgpu/Canvas.h"
 #include "rnwgpu/PlatformContext.h"
 
 namespace rnwgpu {