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

package/cpp/rnskia/RNSkManager.cpp

@@ -11,27 +11,6 @@
 
 #include "jsi/RuntimeAwareCache.h"
 
-#ifdef SK_GRAPHITE
-#include "RNDawnContext.h"
-#include "jsi/Promise.h"
-#include "rnwgpu/ArrayBuffer.h"
-#include "rnwgpu/api/GPU.h"
-#include "rnwgpu/api/GPUUncapturedErrorEvent.h"
-#include "rnwgpu/api/ImageBitmap.h"
-#include "rnwgpu/api/RNWebGPU.h"
-#include "rnwgpu/api/WebGPUConstants.h"
-#include "rnwgpu/api/descriptors/GPUBufferUsage.h"
-#include "rnwgpu/api/descriptors/GPUColorWrite.h"
-#include "rnwgpu/api/descriptors/GPUMapMode.h"
-#include "rnwgpu/api/descriptors/GPUShaderStage.h"
-#include "rnwgpu/api/descriptors/GPUTextureUsage.h"
-#include "rnwgpu/async/RuntimeContext.h"
-
-#include "include/core/SkData.h"
-#include "include/core/SkImage.h"
-#include "include/core/SkImageInfo.h"
-#endif
-
 namespace RNSkia {
 namespace jsi = facebook::jsi;
 
@@ -43,7 +22,7 @@ RNSkManager::RNSkManager(
       _jsCallInvoker(jsCallInvoker),
       _viewApi(std::make_shared<RNSkJsiViewApi>(platformContext)) {
 
-  // Register main runtime (used by both Skia and WebGPU bindings)
+  // Register main runtime
   RNJsi::BaseRuntimeAwareCache::setMainJsRuntime(_jsRuntime);
 
   // Install bindings
@@ -51,12 +30,6 @@ RNSkManager::RNSkManager(
 }
 
 RNSkManager::~RNSkManager() {
-#ifdef SK_GRAPHITE
-  // Drop all canvas registry entries: after a reload the JS side restarts its
-  // contextId counter, and stale entries would alias new canvases onto dead
-  // surfaces.
-  rnwgpu::SurfaceRegistry::getInstance().clear();
-#endif
   // Free up any references
   _viewApi = nullptr;
   _jsRuntime = nullptr;
@@ -87,139 +60,9 @@ void RNSkManager::installBindings() {
   _jsRuntime->global().setProperty(*_jsRuntime, "SkiaViewApi",
                                    makeJsiObject(*_jsRuntime, _viewApi));
 
-#ifdef SK_GRAPHITE
-  // Register the main runtime + its CallInvoker so spontaneous events
-  // (device.lost / uncapturederror) on main-runtime devices can be delivered to
-  // the JS thread without the ProcessEvents pump. Worklet-runtime devices have
-  // no invoker (best-effort; see the RuntimeContext "Threading model" doc).
-  rnwgpu::async::RuntimeContext::registerMainRuntime(_jsRuntime,
-                                                     _jsCallInvoker);
-
-  // Install WebGPU constructors
-  rnwgpu::GPU::installConstructor(*_jsRuntime);
-  rnwgpu::GPUUncapturedErrorEvent::installConstructor(*_jsRuntime);
-  // Create and expose navigator.gpu using DawnContext's instance
-  auto &dawnContext = DawnContext::getInstance();
-  auto gpu =
-      std::make_shared<rnwgpu::GPU>(*_jsRuntime, dawnContext.getWGPUInstance());
-  auto navigatorValue =
-      _jsRuntime->global().getProperty(*_jsRuntime, "navigator");
-  if (navigatorValue.isObject()) {
-    auto navigator = navigatorValue.asObject(*_jsRuntime);
-    navigator.setProperty(*_jsRuntime, "gpu",
-                          rnwgpu::GPU::create(*_jsRuntime, gpu));
-  } else {
-    // Create navigator object if it doesn't exist
-    jsi::Object navigator(*_jsRuntime);
-    navigator.setProperty(*_jsRuntime, "gpu",
-                          rnwgpu::GPU::create(*_jsRuntime, gpu));
-    _jsRuntime->global().setProperty(*_jsRuntime, "navigator",
-                                     std::move(navigator));
-  }
-
-  // Install WebGPU constant objects as plain JS objects on the main runtime.
-  rnwgpu::installWebGPUConstants(*_jsRuntime);
-
-  // Install a global `installWebGPU()` host function so worklet runtimes can
-  // get the same constants. A host function captured into a worklet is
-  // serialized as a SerializableHostFunction and re-created on the worklet
-  // runtime, so the body runs there (its `rt` is the worklet runtime) and
-  // installs the constants on that runtime. The constants come from the native
-  // wgpu::*Usage enums, so the values stay a single source of truth across
-  // every runtime. Calling it on a runtime that already has the globals is a
-  // safe, idempotent no-op.
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "installWebGPU",
-      jsi::Function::createFromHostFunction(
-          *_jsRuntime, jsi::PropNameID::forAscii(*_jsRuntime, "installWebGPU"),
-          0,
-          [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
-             const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
-            rnwgpu::installWebGPUConstants(rt);
-            return jsi::Value::undefined();
-          }));
-
-  // 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));
-
-  // DRAFT — compile-unverified. Install the ImageBitmap constructor (so
-  // `instanceof ImageBitmap` works) and a global createImageBitmap() that
-  // accepts the non-standard encoded-BufferSource overload.
-  //
-  // The BufferSource is run through the shared rnwgpu::ArrayBuffer converter,
-  // which validates byteOffset/byteLength against the backing buffer and throws
-  // synchronously on a spoofed / out-of-bounds view — so createImageBitmap()
-  // rejects rather than reading out of bounds (see ArrayBufferBounds /
-  // ImageBitmapBounds specs). Decoding uses Skia's own codec; no platform image
-  // decoder is needed.
-  rnwgpu::ImageBitmap::installConstructor(*_jsRuntime);
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "createImageBitmap",
-      jsi::Function::createFromHostFunction(
-          *_jsRuntime,
-          jsi::PropNameID::forAscii(*_jsRuntime, "createImageBitmap"), 1,
-          [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
-             const jsi::Value *args, size_t count) -> jsi::Value {
-            if (count < 1 || !args[0].isObject()) {
-              throw jsi::JSError(
-                  rt, "createImageBitmap requires a BufferSource argument");
-            }
-            // Only the encoded ArrayBuffer / ArrayBufferView overload is
-            // supported here. Anything else (Blob, ImageData, …) is rejected.
-            auto obj = args[0].getObject(rt);
-            bool isBufferSource = obj.isArrayBuffer(rt);
-            if (!isBufferSource && obj.hasProperty(rt, "buffer")) {
-              auto bufferProp = obj.getProperty(rt, "buffer");
-              isBufferSource = bufferProp.isObject() &&
-                               bufferProp.getObject(rt).isArrayBuffer(rt);
-            }
-            if (!isBufferSource) {
-              throw jsi::JSError(rt, "createImageBitmap: unsupported source "
-                                     "(expected an ArrayBuffer or TypedArray "
-                                     "of encoded image bytes)");
-            }
-            // Validates bounds and THROWS synchronously on a spoofed view, so
-            // the bad pointer never reaches the copy below.
-            auto buffer = rnwgpu::JSIConverter<
-                std::shared_ptr<rnwgpu::ArrayBuffer>>::fromJSI(rt, args[0],
-                                                               false);
-            // Copy the encoded bytes off the JS-owned ArrayBuffer.
-            const uint8_t *bytes = buffer->data();
-            std::vector<uint8_t> encoded(bytes, bytes + buffer->size());
-
-            return rnwgpu::Promise::createPromise(
-                rt, [encoded = std::move(encoded)](
-                        jsi::Runtime &runtime,
-                        std::shared_ptr<rnwgpu::Promise> promise) mutable {
-                  auto skData =
-                      SkData::MakeWithCopy(encoded.data(), encoded.size());
-                  auto image = SkImages::DeferredFromEncodedData(skData);
-                  if (image == nullptr) {
-                    promise->reject(
-                        "createImageBitmap: failed to decode image data");
-                    return;
-                  }
-                  const int w = image->width();
-                  const int h = image->height();
-                  auto info = SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
-                                                kUnpremul_SkAlphaType);
-                  std::vector<uint8_t> pixels(info.computeMinByteSize());
-                  // nullptr context: decode/read on the CPU (raster).
-                  if (!image->readPixels(nullptr, info, pixels.data(),
-                                         info.minRowBytes(), 0, 0)) {
-                    promise->reject(
-                        "createImageBitmap: failed to read decoded pixels");
-                    return;
-                  }
-                  auto bitmap = std::make_shared<rnwgpu::ImageBitmap>(
-                      std::move(pixels), static_cast<size_t>(w),
-                      static_cast<size_t>(h));
-                  promise->resolve(
-                      rnwgpu::ImageBitmap::create(runtime, bitmap));
-                });
-          }));
-#endif
+  // The WebGPU JS API (RNWebGPU, navigator.gpu, constants, createImageBitmap)
+  // is no longer installed here: react-native-webgpu is the single WebGPU API
+  // surface for React Native. Graphite keeps Dawn as an internal
+  // implementation detail only.
 }
 } // namespace RNSkia

package/cpp/skia/include/gpu/ganesh/GrDriverBugWorkaroundsAutogen.h

@@ -21,6 +21,8 @@
          disallow_large_instanced_draw)                 \
   GPU_OP(EMULATE_ABS_INT_FUNCTION,                      \
          emulate_abs_int_function)                      \
+  GPU_OP(ENSURE_PREVIOUS_FRAMEBUFFER_NOT_DELETED,       \
+         ensure_previous_framebuffer_not_deleted)       \
   GPU_OP(FLUSH_ON_FRAMEBUFFER_CHANGE,                   \
          flush_on_framebuffer_change)                   \
   GPU_OP(FORCE_UPDATE_SCISSOR_STATE_WHEN_BINDING_FBO0,  \

package/cpp/skia/src/gpu/graphite/ContextOptionsPriv.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_ContextOptionsPriv_DEFINED
+#define skgpu_graphite_ContextOptionsPriv_DEFINED
+
+#include "include/private/base/SkMath.h"
+
+#include <optional>
+
+namespace skgpu::graphite {
+
+enum class PathRendererStrategy;
+
+/**
+ * Private options that are only meant for testing within Skia's tools.
+ */
+struct ContextOptionsPriv {
+
+    int  fMaxTextureSizeOverride = SK_MaxS32;
+
+    /**
+     * If true, will store a pointer in Recorder that points back to the Context
+     * that created it. Used by readPixels() and other methods that normally require a Context.
+     */
+    bool fStoreContextRefInRecorder = false;
+
+    /**
+     * If true, enables layer based draw ordering.
+     */
+    bool fDrawListLayer = false;
+
+    /**
+     * Override Caps' default strategy heuristics to prioritize this one if set *and* is supported.
+     */
+    std::optional<PathRendererStrategy> fPathRendererStrategy;
+};
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_ContextOptionsPriv_DEFINED

package/cpp/skia/src/gpu/graphite/ResourceTypes.h

@@ -0,0 +1,360 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_ResourceTypes_DEFINED
+#define skgpu_graphite_ResourceTypes_DEFINED
+
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTileMode.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/private/base/SkTo.h"
+#include "src/base/SkEnumBitMask.h"
+#include "src/base/SkMathPriv.h"
+
+namespace skgpu::graphite {
+
+class Buffer;
+
+// This declaration of the DepthStencilFlags' SkEnumBitMask ops is here bc, internally, we use
+// DepthStencilFlags as bit fields but, externally (i.e., from the GraphiteTypes view), we want
+// it to appear as just an enum class.
+SK_MAKE_BITMASK_OPS(DepthStencilFlags)
+// The same goes for SampleCount
+SK_MAKE_BITMASK_OPS(SampleCount)
+
+/**
+ * There are only a few possible valid sample counts (1, 2, 4, 8, 16). So we can key on those 5
+ * options instead of the actual sample value. The resulting key value only requires 3 bits of space
+ */
+static constexpr uint32_t SamplesToKey(SampleCount numSamples) {
+    switch (numSamples) {
+        case SampleCount::k1:
+            return 0;
+        case SampleCount::k2:
+            return 1;
+        case SampleCount::k4:
+            return 2;
+        case SampleCount::k8:
+            return 3;
+        case SampleCount::k16:
+            return 4;
+    }
+    SkUNREACHABLE;
+}
+static constexpr SampleCount KeyToSamples(uint32_t keyBits) {
+    SkASSERT(keyBits <= 4);
+    return static_cast<SampleCount>(1 << keyBits);
+}
+static constexpr int kNumSampleKeyBits = 3;
+
+/**
+ * The strategy that a renderpass and/or pipeline use to access the current dst pixel when blending.
+ */
+enum class DstReadStrategy : uint8_t {
+    kNoneRequired,
+    kTextureCopy,
+    kTextureSample,  // TODO(b/238756862): To be used once direct texture sampling is implemented
+    kReadFromInput,
+    kFramebufferFetch,
+
+    kLast = kFramebufferFetch
+};
+inline static constexpr int kDstReadStrategyCount = (int)(DstReadStrategy::kLast) + 1;
+
+/**
+ * This enum is used to specify the load operation to be used when a RenderPass begins execution.
+ */
+enum class LoadOp : uint8_t {
+    kLoad,
+    kClear,
+    kDiscard,
+
+    kLast = kDiscard
+};
+inline static constexpr int kLoadOpCount = (int)(LoadOp::kLast) + 1;
+
+/**
+ * This enum is used to specify the store operation to be used when a RenderPass ends execution.
+ */
+enum class StoreOp : uint8_t {
+    kStore,
+    kDiscard,
+
+    kLast = kDiscard
+};
+inline static constexpr int kStoreOpCount = (int)(StoreOp::kLast) + 1;
+
+/**
+ * What a GPU buffer will be used for
+ */
+enum class BufferType : int {
+    kVertex,
+    kIndex,
+    kXferCpuToGpu,
+    kXferGpuToCpu,
+    kUniform,
+    kStorage,
+    kQuery,
+
+    // GPU-only buffer types
+    kIndirect,
+    kVertexStorage,
+    kIndexStorage,
+
+    kLast = kIndexStorage,
+};
+static const int kBufferTypeCount = static_cast<int>(BufferType::kLast) + 1;
+
+/**
+ * Data layout requirements on host-shareable buffer contents.
+ */
+enum class Layout : uint8_t {
+    kInvalid = 0,
+    kStd140,
+    kStd140_F16,
+    kStd430,
+    kStd430_F16,
+    kMetal,
+};
+
+static constexpr const char* LayoutString(Layout layout) {
+    switch(layout) {
+        case Layout::kStd140:     return "std140";
+        case Layout::kStd140_F16: return "std140-f16";
+        case Layout::kStd430:     return "std430";
+        case Layout::kStd430_F16: return "std430-f16";
+        case Layout::kMetal:      return "metal";
+        case Layout::kInvalid:    return "invalid";
+    }
+    SkUNREACHABLE;
+}
+
+/**
+ * Indicates the intended access pattern over resource memory. This is used to select the most
+ * efficient memory type during resource creation based on the capabilities of the platform.
+ *
+ * This is only a hint and the actual memory type will be determined based on the resource type and
+ * backend capabilities.
+ */
+enum class AccessPattern : uint8_t {
+    // GPU-only memory does not need to support reads/writes from the CPU. GPU-private memory will
+    // be preferred if the backend supports an efficient private memory type.
+    kGpuOnly,
+
+    // The resource needs to be CPU visible, e.g. for read-back or as a copy/upload source.
+    kHostVisible,
+
+    // Use to debug GPU only buffers.
+    kGpuOnlyCopySrc,
+};
+
+/**
+ * Determines whether the contents of a GPU buffer sub-allocation gets cleared to 0 before being
+ * used in a GPU command submission.
+ */
+enum class ClearBuffer : bool {
+    kNo = false,
+    kYes = true,
+};
+
+/**
+ * Must the contents of the Resource be preserved af a render pass or can a more efficient
+ * representation be chosen when supported by hardware.
+ */
+enum class Discardable : bool {
+    kNo = false,
+    kYes = true
+};
+
+enum class Ownership : uint8_t {
+    kOwned,
+    kWrapped,
+};
+
+/** Uniquely identifies the type of resource that is cached with a GraphiteResourceKey. */
+using ResourceType = uint32_t;
+
+/**
+ * Can the resource be held by multiple users at the same time?
+ * For example, stencil buffers, pipelines, etc.
+ */
+enum class Shareable : uint8_t {
+    kNo,      // The resource is visible in the ResourceCache once all its usage refs are dropped
+    kScratch, // The resource is visible to other Recorders, but acts like kNo within a Recording
+    kYes,     // The resource is always visible in the ResourceCache
+};
+
+/*
+ * Struct that can be passed into bind buffer calls on the CommandBuffer. The ownership of the
+ * buffer and its usage in command submission must be tracked by the caller (e.g. as with
+ * buffers created by DrawBufferManager).
+ */
+struct BindBufferInfo {
+    const Buffer* fBuffer = nullptr;
+    uint32_t fOffset = 0;
+    uint32_t fSize = 0;
+
+    explicit operator bool() const { return SkToBool(fBuffer); }
+
+    bool operator==(const BindBufferInfo& o) const {
+        return fBuffer == o.fBuffer && (!fBuffer || (fOffset == o.fOffset && fSize == o.fSize));
+    }
+    bool operator!=(const BindBufferInfo& o) const { return !(*this == o); }
+};
+
+// How texture memory is arranged on the GPU, which can impact what operations are supported.
+enum class Tiling : uint8_t {
+    kOptimal,
+    kLinear
+};
+
+// Coarse ways in which a specific texture can be used, or the theoretic set of usages a texture
+// format supports.
+enum class TextureUsage : uint8_t {
+    kRender   = 0x01, // Can be used as a rendering attachment
+    kMSRTSS   = 0x02, // Can be rendered with MSAA-render-to-single-sampled functionality
+    kSample   = 0x04, // Can be sampled within a shader
+    kCopySrc  = 0x08, // Can be copied into another texture or buffer
+    kCopyDst  = 0x10, // Can be the copy target of another texture or buffer
+    kStorage  = 0x20, // Can be read and written to in a compute pipeline
+    kHostCopy = 0x40, // Can be written to directly from host memory
+};
+SK_MAKE_BITMASK_OPS(TextureUsage)
+
+struct ImmutableSamplerInfo {
+    // If the sampler requires YCbCr conversion, backends can place that information here.
+    // In order to fit within SamplerDesc's uint32 desc field, backends can only utilize up to
+    // kMaxNumConversionInfoBits bits.
+    uint32_t fNonFormatYcbcrConversionInfo = 0;
+    // fFormat represents known OR external format numerical representation.
+    uint64_t fFormat = 0;
+};
+
+/**
+ * Struct used to describe how a Texture/TextureProxy/TextureProxyView is sampled.
+ */
+struct SamplerDesc {
+    static_assert(kSkTileModeCount <= 4 && kSkFilterModeCount <= 2 && kSkMipmapModeCount <= 4);
+
+    constexpr SamplerDesc(const SkSamplingOptions& samplingOptions, SkTileMode tileMode)
+            : SamplerDesc(samplingOptions, {tileMode, tileMode}) {}
+
+    constexpr SamplerDesc(const SkSamplingOptions& samplingOptions,
+                          const std::pair<SkTileMode, SkTileMode> tileModes,
+                          const ImmutableSamplerInfo info = {})
+            : fDesc((static_cast<int>(tileModes.first)            << kTileModeXShift           ) |
+                    (static_cast<int>(tileModes.second)           << kTileModeYShift           ) |
+                    (static_cast<int>(samplingOptions.filter)     << kFilterModeShift          ) |
+                    (static_cast<int>(samplingOptions.mipmap)     << kMipmapModeShift          ) |
+                    (info.fNonFormatYcbcrConversionInfo           << kImmutableSamplerInfoShift) )
+            , fFormat(info.fFormat)
+            , fExternalFormatMostSignificantBits(info.fFormat >> 32) {
+
+        // Cubic sampling is handled in a shader, with the actual texture sampled by with NN,
+        // but that is what a cubic SkSamplingOptions is set to if you ignore 'cubic', which let's
+        // us simplify how we construct SamplerDec's from the options passed to high-level draws.
+        SkASSERT(!samplingOptions.useCubic || (samplingOptions.filter == SkFilterMode::kNearest &&
+                                               samplingOptions.mipmap == SkMipmapMode::kNone));
+
+        // TODO: Add aniso value when used.
+
+        // Assert that fYcbcrConversionInfo does not exceed kMaxNumConversionInfoBits such that
+        // the conversion information can fit within an uint32.
+        SkASSERT(info.fNonFormatYcbcrConversionInfo >> kMaxNumConversionInfoBits == 0);
+    }
+    constexpr SamplerDesc() = default;
+    constexpr SamplerDesc(const SamplerDesc&) = default;
+    constexpr SamplerDesc& operator=(const SamplerDesc&) = default;
+
+    constexpr SamplerDesc(uint32_t desc, uint32_t format, uint32_t extFormatMSB)
+            : fDesc(desc)
+            , fFormat(format)
+            , fExternalFormatMostSignificantBits(extFormatMSB) {}
+
+    bool operator==(const SamplerDesc& o) const {
+        return o.fDesc == fDesc && o.fFormat == fFormat &&
+               o.fExternalFormatMostSignificantBits == fExternalFormatMostSignificantBits;
+    }
+
+    bool operator!=(const SamplerDesc& o) const { return !(*this == o); }
+
+    SkTileMode tileModeX()          const {
+        return static_cast<SkTileMode>((fDesc >> kTileModeXShift) & 0b11);
+    }
+    SkTileMode tileModeY()          const {
+        return static_cast<SkTileMode>((fDesc >> kTileModeYShift) & 0b11);
+    }
+    SkFilterMode filterMode()       const {
+        return static_cast<SkFilterMode>((fDesc >> kFilterModeShift) & 0b01);
+    }
+    SkMipmapMode mipmap()           const {
+        return static_cast<SkMipmapMode>((fDesc >> kMipmapModeShift) & 0b11);
+    }
+    uint32_t   desc()               const { return fDesc;                                        }
+    uint32_t   format()             const { return fFormat;                                      }
+    uint32_t   externalFormatMSBs() const { return fExternalFormatMostSignificantBits;           }
+    bool       isImmutable()        const { return (fDesc >> kImmutableSamplerInfoShift) != 0;   }
+    bool       usesExternalFormat() const { return (fDesc >> kImmutableSamplerInfoShift) & 0b1;  }
+
+    // NOTE: returns the HW sampling options to use, so a bicubic SkSamplingOptions will become
+    // nearest-neighbor sampling in HW.
+    SkSamplingOptions samplingOptions() const {
+        // TODO: Add support for anisotropic filtering
+        SkFilterMode filter = static_cast<SkFilterMode>((fDesc >> kFilterModeShift) & 0b01);
+        SkMipmapMode mipmap = static_cast<SkMipmapMode>((fDesc >> kMipmapModeShift) & 0b11);
+        return SkSamplingOptions(filter, mipmap);
+    }
+
+    ImmutableSamplerInfo immutableSamplerInfo() const {
+        return {this->desc() >> kImmutableSamplerInfoShift,
+                ((uint64_t) this->externalFormatMSBs() << 32) | (uint64_t) this->format()};
+    }
+
+    SkSpan<const uint32_t> asSpan() const {
+        // Span length depends upon whether the sampler is immutable and if it uses a known format
+        return {&fDesc, 1u + this->isImmutable() + this->usesExternalFormat()};
+    }
+
+    // These are public such that backends can bitshift data in order to determine whatever
+    // sampler qualities they need from fDesc.
+    static constexpr int kNumTileModeBits   = SkNextLog2(int(SkTileMode::kLastTileMode)+1);
+    static constexpr int kNumFilterModeBits = SkNextLog2(int(SkFilterMode::kLast)+1);
+    static constexpr int kNumMipmapModeBits = SkNextLog2(int(SkMipmapMode::kLast)+1);
+    static constexpr int kMaxNumConversionInfoBits =
+            32 - kNumFilterModeBits - kNumMipmapModeBits - kNumTileModeBits;
+
+    static constexpr int kTileModeXShift            = 0;
+    static constexpr int kTileModeYShift            = kTileModeXShift  + kNumTileModeBits;
+    static constexpr int kFilterModeShift           = kTileModeYShift  + kNumTileModeBits;
+    static constexpr int kMipmapModeShift           = kFilterModeShift + kNumFilterModeBits;
+    static constexpr int kImmutableSamplerInfoShift = kMipmapModeShift + kNumMipmapModeBits;
+
+    // Only relevant when using immutable samplers. Otherwise, can be ignored. The number of uint32s
+    // required to represent all relevant sampler desc information depends upon whether we are using
+    // a known or external format.
+    static constexpr int kInt32sNeededKnownFormat = 2;
+    static constexpr int kInt32sNeededExternalFormat = 3;
+
+private:
+    // Note: The order of these member attributes matters to keep unique object representation
+    // such that SkGoodHash can be used to hash SamplerDesc objects.
+    uint32_t fDesc = 0;
+
+    // Data fields populated by backend Caps which store texture format information (needed for
+    // YCbCr sampling). Only relevant when using immutable samplers. Otherwise, can be ignored.
+    // Known formats only require a uint32, but external formats can be up to a uint64. We store
+    // this as two separate uint32s such that has_unique_object_representation can be true, allowing
+    // this structure to be easily hashed using SkGoodHash. So, external formats can be represented
+    // with (fExternalFormatMostSignificantBits << 32) | fFormat.
+    uint32_t fFormat = 0;
+    uint32_t fExternalFormatMostSignificantBits = 0;
+};
+
+}  // namespace skgpu::graphite
+
+#endif // skgpu_graphite_ResourceTypes_DEFINED