@shopify/react-native-skia 0.0.135

package/cpp/skia/include/gpu/GrTypes.h

@@ -0,0 +1,244 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrTypes_DEFINED
+#define GrTypes_DEFINED
+
+#include "include/core/SkMath.h"
+#include "include/core/SkTypes.h"
+#include "include/gpu/GrConfig.h"
+
+class GrBackendSemaphore;
+class SkImage;
+class SkSurface;
+
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Wraps a C++11 enum that we use as a bitfield, and enables a limited amount of
+ * masking with type safety. Instantiated with the ~ operator.
+ */
+template<typename TFlags> class GrTFlagsMask {
+public:
+    constexpr explicit GrTFlagsMask(TFlags value) : GrTFlagsMask(static_cast<int>(value)) {}
+    constexpr explicit GrTFlagsMask(int value) : fValue(value) {}
+    constexpr int value() const { return fValue; }
+private:
+    const int fValue;
+};
+
+/**
+ * Defines bitwise operators that make it possible to use an enum class as a
+ * basic bitfield.
+ */
+#define GR_MAKE_BITFIELD_CLASS_OPS(X) \
+    SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator~(X a) { \
+        return GrTFlagsMask<X>(~static_cast<int>(a)); \
+    } \
+    SK_MAYBE_UNUSED constexpr X operator|(X a, X b) { \
+        return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \
+    } \
+    SK_MAYBE_UNUSED inline X& operator|=(X& a, X b) { \
+        return (a = a | b); \
+    } \
+    SK_MAYBE_UNUSED constexpr bool operator&(X a, X b) { \
+        return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \
+    } \
+    SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
+        return GrTFlagsMask<X>(a.value() | b.value()); \
+    } \
+    SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X> a, X b) { \
+        return GrTFlagsMask<X>(a.value() | static_cast<int>(b)); \
+    } \
+    SK_MAYBE_UNUSED constexpr GrTFlagsMask<X> operator|(X a, GrTFlagsMask<X> b) { \
+        return GrTFlagsMask<X>(static_cast<int>(a) | b.value()); \
+    } \
+    SK_MAYBE_UNUSED constexpr X operator&(GrTFlagsMask<X> a, GrTFlagsMask<X> b) { \
+        return static_cast<X>(a.value() & b.value()); \
+    } \
+    SK_MAYBE_UNUSED constexpr X operator&(GrTFlagsMask<X> a, X b) { \
+        return static_cast<X>(a.value() & static_cast<int>(b)); \
+    } \
+    SK_MAYBE_UNUSED constexpr X operator&(X a, GrTFlagsMask<X> b) { \
+        return static_cast<X>(static_cast<int>(a) & b.value()); \
+    } \
+    SK_MAYBE_UNUSED inline X& operator&=(X& a, GrTFlagsMask<X> b) { \
+        return (a = a & b); \
+    } \
+
+#define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \
+    friend constexpr GrTFlagsMask<X> operator ~(X); \
+    friend constexpr X operator |(X, X); \
+    friend X& operator |=(X&, X); \
+    friend constexpr bool operator &(X, X); \
+    friend constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X>, GrTFlagsMask<X>); \
+    friend constexpr GrTFlagsMask<X> operator|(GrTFlagsMask<X>, X); \
+    friend constexpr GrTFlagsMask<X> operator|(X, GrTFlagsMask<X>); \
+    friend constexpr X operator&(GrTFlagsMask<X>, GrTFlagsMask<X>); \
+    friend constexpr X operator&(GrTFlagsMask<X>, X); \
+    friend constexpr X operator&(X, GrTFlagsMask<X>); \
+    friend X& operator &=(X&, GrTFlagsMask<X>)
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Possible 3D APIs that may be used by Ganesh.
+ */
+enum class GrBackendApi : unsigned {
+    kOpenGL,
+    kVulkan,
+    kMetal,
+    kDirect3D,
+    kDawn,
+    /**
+     * Mock is a backend that does not draw anything. It is used for unit tests
+     * and to measure CPU overhead.
+     */
+    kMock,
+
+    /**
+     * Added here to support the legacy GrBackend enum value and clients who referenced it using
+     * GrBackend::kOpenGL_GrBackend.
+     */
+    kOpenGL_GrBackend = kOpenGL,
+};
+
+/**
+ * Previously the above enum was not an enum class but a normal enum. To support the legacy use of
+ * the enum values we define them below so that no clients break.
+ */
+typedef GrBackendApi GrBackend;
+
+static constexpr GrBackendApi kMetal_GrBackend = GrBackendApi::kMetal;
+static constexpr GrBackendApi kVulkan_GrBackend = GrBackendApi::kVulkan;
+static constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock;
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Used to say whether a texture has mip levels allocated or not.
+ */
+enum class GrMipmapped : bool {
+    kNo = false,
+    kYes = true
+};
+/** Deprecated legacy alias of GrMipmapped. */
+using GrMipMapped = GrMipmapped;
+
+/*
+ * Can a GrBackendObject be rendered to?
+ */
+enum class GrRenderable : bool {
+    kNo = false,
+    kYes = true
+};
+
+/*
+ * Used to say whether texture is backed by protected memory.
+ */
+enum class GrProtected : bool {
+    kNo = false,
+    kYes = true
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * GPU SkImage and SkSurfaces can be stored such that (0, 0) in texture space may correspond to
+ * either the top-left or bottom-left content pixel.
+ */
+enum GrSurfaceOrigin : int {
+    kTopLeft_GrSurfaceOrigin,
+    kBottomLeft_GrSurfaceOrigin,
+};
+
+/**
+ * A GrContext's cache of backend context state can be partially invalidated.
+ * These enums are specific to the GL backend and we'd add a new set for an alternative backend.
+ */
+enum GrGLBackendState {
+    kRenderTarget_GrGLBackendState     = 1 << 0,
+    // Also includes samplers bound to texture units.
+    kTextureBinding_GrGLBackendState   = 1 << 1,
+    // View state stands for scissor and viewport
+    kView_GrGLBackendState             = 1 << 2,
+    kBlend_GrGLBackendState            = 1 << 3,
+    kMSAAEnable_GrGLBackendState       = 1 << 4,
+    kVertex_GrGLBackendState           = 1 << 5,
+    kStencil_GrGLBackendState          = 1 << 6,
+    kPixelStore_GrGLBackendState       = 1 << 7,
+    kProgram_GrGLBackendState          = 1 << 8,
+    kFixedFunction_GrGLBackendState    = 1 << 9,
+    kMisc_GrGLBackendState             = 1 << 10,
+    kALL_GrGLBackendState              = 0xffff
+};
+
+/**
+ * This value translates to reseting all the context state for any backend.
+ */
+static const uint32_t kAll_GrBackendState = 0xffffffff;
+
+typedef void* GrGpuFinishedContext;
+typedef void (*GrGpuFinishedProc)(GrGpuFinishedContext finishedContext);
+
+typedef void* GrGpuSubmittedContext;
+typedef void (*GrGpuSubmittedProc)(GrGpuSubmittedContext submittedContext, bool success);
+
+/**
+ * Struct to supply options to flush calls.
+ *
+ * After issuing all commands, fNumSemaphore semaphores will be signaled by the gpu. The client
+ * passes in an array of fNumSemaphores GrBackendSemaphores. In general these GrBackendSemaphore's
+ * can be either initialized or not. If they are initialized, the backend uses the passed in
+ * semaphore. If it is not initialized, a new semaphore is created and the GrBackendSemaphore
+ * object is initialized with that semaphore. The semaphores are not sent to the GPU until the next
+ * GrContext::submit call is made. See the GrContext::submit for more information.
+ *
+ * The client will own and be responsible for deleting the underlying semaphores that are stored
+ * and returned in initialized GrBackendSemaphore objects. The GrBackendSemaphore objects
+ * themselves can be deleted as soon as this function returns.
+ *
+ * If a finishedProc is provided, the finishedProc will be called when all work submitted to the gpu
+ * from this flush call and all previous flush calls has finished on the GPU. If the flush call
+ * fails due to an error and nothing ends up getting sent to the GPU, the finished proc is called
+ * immediately.
+ *
+ * If a submittedProc is provided, the submittedProc will be called when all work from this flush
+ * call is submitted to the GPU. If the flush call fails due to an error and nothing will get sent
+ * to the GPU, the submitted proc is called immediately. It is possibly that when work is finally
+ * submitted, that the submission actual fails. In this case we will not reattempt to do the
+ * submission. Skia notifies the client of these via the success bool passed into the submittedProc.
+ * The submittedProc is useful to the client to know when semaphores that were sent with the flush
+ * have actually been submitted to the GPU so that they can be waited on (or deleted if the submit
+ * fails).
+ * Note about GL: In GL work gets sent to the driver immediately during the flush call, but we don't
+ * really know when the driver sends the work to the GPU. Therefore, we treat the submitted proc as
+ * we do in other backends. It will be called when the next GrContext::submit is called after the
+ * flush (or possibly during the flush if there is no work to be done for the flush). The main use
+ * case for the submittedProc is to know when semaphores have been sent to the GPU and even in GL
+ * it is required to call GrContext::submit to flush them. So a client should be able to treat all
+ * backend APIs the same in terms of how the submitted procs are treated.
+ */
+struct GrFlushInfo {
+    size_t fNumSemaphores = 0;
+    GrBackendSemaphore* fSignalSemaphores = nullptr;
+    GrGpuFinishedProc fFinishedProc = nullptr;
+    GrGpuFinishedContext fFinishedContext = nullptr;
+    GrGpuSubmittedProc fSubmittedProc = nullptr;
+    GrGpuSubmittedContext fSubmittedContext = nullptr;
+};
+
+/**
+ * Enum used as return value when flush with semaphores so the client knows whether the valid
+ * semaphores will be submitted on the next GrContext::submit call.
+ */
+enum class GrSemaphoresSubmitted : bool {
+    kNo = false,
+    kYes = true
+};
+
+#endif

package/cpp/skia/include/gpu/GrYUVABackendTextures.h

@@ -0,0 +1,124 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrYUVABackendTextures_DEFINED
+#define GrYUVABackendTextures_DEFINED
+
+#include "include/core/SkYUVAInfo.h"
+#include "include/gpu/GrBackendSurface.h"
+
+#include <tuple>
+
+/**
+ * A description of a set GrBackendTextures that hold the planar data described by a SkYUVAInfo.
+ */
+class SK_API GrYUVABackendTextureInfo {
+public:
+    static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
+
+    /** Default GrYUVABackendTextureInfo is invalid. */
+    GrYUVABackendTextureInfo() = default;
+
+    /**
+     * Initializes a GrYUVABackendTextureInfo to describe a set of textures that can store the
+     * planes indicated by the SkYUVAInfo. The texture dimensions are taken from the SkYUVAInfo's
+     * plane dimensions. All the described textures share a common origin. The planar image this
+     * describes will be mip mapped if all the textures are individually mip mapped as indicated
+     * by GrMipmapped. This will produce an invalid result (return false from isValid()) if the
+     * passed formats' channels don't agree with SkYUVAInfo.
+     */
+    GrYUVABackendTextureInfo(const SkYUVAInfo&,
+                             const GrBackendFormat[kMaxPlanes],
+                             GrMipmapped,
+                             GrSurfaceOrigin);
+
+    GrYUVABackendTextureInfo(const GrYUVABackendTextureInfo&) = default;
+
+    GrYUVABackendTextureInfo& operator=(const GrYUVABackendTextureInfo&) = default;
+
+    bool operator==(const GrYUVABackendTextureInfo&) const;
+    bool operator!=(const GrYUVABackendTextureInfo& that) const { return !(*this == that); }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
+
+    GrMipmapped mipmapped() const { return fMipmapped; }
+
+    GrSurfaceOrigin textureOrigin() const { return fTextureOrigin; }
+
+    /** The number of SkPixmap planes, 0 if this GrYUVABackendTextureInfo is invalid. */
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    /** Format of the ith plane, or invalid format if i >= numPlanes() */
+    const GrBackendFormat& planeFormat(int i) const { return fPlaneFormats[i]; }
+
+    /**
+     * Returns true if this has been configured with a valid SkYUVAInfo with compatible texture
+     * formats.
+     */
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    /**
+     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
+     * valid if this->isValid().
+     */
+    SkYUVAInfo::YUVALocations toYUVALocations() const;
+
+private:
+    SkYUVAInfo fYUVAInfo;
+    GrBackendFormat fPlaneFormats[kMaxPlanes];
+    GrMipmapped fMipmapped = GrMipmapped::kNo;
+    GrSurfaceOrigin fTextureOrigin = kTopLeft_GrSurfaceOrigin;
+};
+
+/**
+ * A set of GrBackendTextures that hold the planar data for an image described a SkYUVAInfo.
+ */
+class SK_API GrYUVABackendTextures {
+public:
+    GrYUVABackendTextures() = default;
+    GrYUVABackendTextures(const GrYUVABackendTextures&) = delete;
+    GrYUVABackendTextures(GrYUVABackendTextures&&) = default;
+
+    GrYUVABackendTextures& operator=(const GrYUVABackendTextures&) = delete;
+    GrYUVABackendTextures& operator=(GrYUVABackendTextures&&) = default;
+
+    GrYUVABackendTextures(const SkYUVAInfo&,
+                          const GrBackendTexture[SkYUVAInfo::kMaxPlanes],
+                          GrSurfaceOrigin textureOrigin);
+
+    const std::array<GrBackendTexture, SkYUVAInfo::kMaxPlanes>& textures() const {
+        return fTextures;
+    }
+
+    GrBackendTexture texture(int i) const {
+        SkASSERT(i >= 0 && i < SkYUVAInfo::kMaxPlanes);
+        return fTextures[static_cast<size_t>(i)];
+    }
+
+    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
+
+    int numPlanes() const { return fYUVAInfo.numPlanes(); }
+
+    GrSurfaceOrigin textureOrigin() const { return fTextureOrigin; }
+
+    bool isValid() const { return fYUVAInfo.isValid(); }
+
+    /**
+     * Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
+     * valid if this->isValid().
+     */
+    SkYUVAInfo::YUVALocations toYUVALocations() const;
+
+private:
+    SkYUVAInfo fYUVAInfo;
+    std::array<GrBackendTexture, SkYUVAInfo::kMaxPlanes> fTextures;
+    GrSurfaceOrigin fTextureOrigin = kTopLeft_GrSurfaceOrigin;
+};
+
+#endif

package/cpp/skia/include/gpu/ShaderErrorHandler.h

@@ -0,0 +1,36 @@
+/*
+ * 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_ShaderErrorHandler_DEFINED
+#define skgpu_ShaderErrorHandler_DEFINED
+
+#include "include/core/SkTypes.h"
+
+namespace skgpu {
+/**
+ * Abstract class to report errors when compiling shaders.
+ */
+class SK_API ShaderErrorHandler {
+public:
+    virtual ~ShaderErrorHandler() = default;
+
+    virtual void compileError(const char* shader, const char* errors) = 0;
+
+protected:
+    ShaderErrorHandler() = default;
+    ShaderErrorHandler(const ShaderErrorHandler&) = delete;
+    ShaderErrorHandler& operator=(const ShaderErrorHandler&) = delete;
+};
+
+/**
+ * Used when no error handler is set. Will report failures via SkDebugf and asserts.
+ */
+ShaderErrorHandler* DefaultShaderErrorHandler();
+
+}  // namespace skgpu
+
+#endif // skgpu_ShaderErrorHandler_DEFINED

package/cpp/skia/include/gpu/d3d/GrD3DBackendContext.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrD3DBackendContext_DEFINED
+#define GrD3DBackendContext_DEFINED
+
+// GrD3DTypes.h includes d3d12.h, which in turn includes windows.h, which redefines many
+// common identifiers such as:
+// * interface
+// * small
+// * near
+// * far
+// * CreateSemaphore
+// * MemoryBarrier
+//
+// You should only include GrD3DBackendContext.h if you are prepared to rename those identifiers.
+#include "include/gpu/d3d/GrD3DTypes.h"
+
+#include "include/gpu/GrTypes.h"
+
+// The BackendContext contains all of the base D3D objects needed by the GrD3DGpu. The assumption
+// is that the client will set these up and pass them to the GrD3DGpu constructor.
+struct SK_API GrD3DBackendContext {
+    gr_cp<IDXGIAdapter1> fAdapter;
+    gr_cp<ID3D12Device> fDevice;
+    gr_cp<ID3D12CommandQueue> fQueue;
+    sk_sp<GrD3DMemoryAllocator> fMemoryAllocator;
+    GrProtected fProtectedContext = GrProtected::kNo;
+};
+
+#endif

package/cpp/skia/include/gpu/d3d/GrD3DTypes.h

@@ -0,0 +1,248 @@
+
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrD3DTypes_DEFINED
+#define GrD3DTypes_DEFINED
+
+// This file includes d3d12.h, which in turn includes windows.h, which redefines many
+// common identifiers such as:
+// * interface
+// * small
+// * near
+// * far
+// * CreateSemaphore
+// * MemoryBarrier
+//
+// You should only include this header if you need the Direct3D definitions and are
+// prepared to rename those identifiers.
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrTypes.h"
+#include <d3d12.h>
+#include <dxgi1_4.h>
+
+class GrD3DGpu;
+
+ /** Check if the argument is non-null, and if so, call obj->AddRef() and return obj.
+  */
+template <typename T> static inline T* GrSafeComAddRef(T* obj) {
+    if (obj) {
+        obj->AddRef();
+    }
+    return obj;
+}
+
+/** Check if the argument is non-null, and if so, call obj->Release()
+ */
+template <typename T> static inline void GrSafeComRelease(T* obj) {
+    if (obj) {
+        obj->Release();
+    }
+}
+
+template <typename T> class gr_cp {
+public:
+    using element_type = T;
+
+    constexpr gr_cp() : fObject(nullptr) {}
+    constexpr gr_cp(std::nullptr_t) : fObject(nullptr) {}
+
+    /**
+     *  Shares the underlying object by calling AddRef(), so that both the argument and the newly
+     *  created gr_cp both have a reference to it.
+     */
+    gr_cp(const gr_cp<T>& that) : fObject(GrSafeComAddRef(that.get())) {}
+
+    /**
+     *  Move the underlying object from the argument to the newly created gr_cp. Afterwards only
+     *  the new gr_cp will have a reference to the object, and the argument will point to null.
+     *  No call to AddRef() or Release() will be made.
+     */
+    gr_cp(gr_cp<T>&& that) : fObject(that.release()) {}
+
+    /**
+     *  Adopt the bare object into the newly created gr_cp.
+     *  No call to AddRef() or Release() will be made.
+     */
+    explicit gr_cp(T* obj) {
+        fObject = obj;
+    }
+
+    /**
+     *  Calls Release() on the underlying object pointer.
+     */
+    ~gr_cp() {
+        GrSafeComRelease(fObject);
+        SkDEBUGCODE(fObject = nullptr);
+    }
+
+    /**
+     *  Shares the underlying object referenced by the argument by calling AddRef() on it. If this
+     *  gr_cp previously had a reference to an object (i.e. not null) it will call Release()
+     *  on that object.
+     */
+    gr_cp<T>& operator=(const gr_cp<T>& that) {
+        if (this != &that) {
+            this->reset(GrSafeComAddRef(that.get()));
+        }
+        return *this;
+    }
+
+    /**
+     *  Move the underlying object from the argument to the gr_cp. If the gr_cp
+     *  previously held a reference to another object, Release() will be called on that object.
+     *  No call to AddRef() will be made.
+     */
+    gr_cp<T>& operator=(gr_cp<T>&& that) {
+        this->reset(that.release());
+        return *this;
+    }
+
+    explicit operator bool() const { return this->get() != nullptr; }
+
+    T* get() const { return fObject; }
+    T* operator->() const { return fObject; }
+    T** operator&() { return &fObject; }
+
+    /**
+     *  Adopt the new object, and call Release() on any previously held object (if not null).
+     *  No call to AddRef() will be made.
+     */
+    void reset(T* object = nullptr) {
+        T* oldObject = fObject;
+        fObject = object;
+        GrSafeComRelease(oldObject);
+    }
+
+    /**
+     *  Shares the new object by calling AddRef() on it. If this gr_cp previously had a
+     *  reference to an object (i.e. not null) it will call Release() on that object.
+     */
+    void retain(T* object) {
+        if (this->fObject != object) {
+            this->reset(GrSafeComAddRef(object));
+        }
+    }
+
+    /**
+     *  Return the original object, and set the internal object to nullptr.
+     *  The caller must assume ownership of the object, and manage its reference count directly.
+     *  No call to Release() will be made.
+     */
+    T* SK_WARN_UNUSED_RESULT release() {
+        T* obj = fObject;
+        fObject = nullptr;
+        return obj;
+    }
+
+private:
+    T* fObject;
+};
+
+template <typename T> inline bool operator==(const gr_cp<T>& a,
+                                             const gr_cp<T>& b) {
+    return a.get() == b.get();
+}
+
+template <typename T> inline bool operator!=(const gr_cp<T>& a,
+                                             const gr_cp<T>& b) {
+    return a.get() != b.get();
+}
+
+// interface classes for the GPU memory allocator
+class GrD3DAlloc : public SkRefCnt {
+public:
+    ~GrD3DAlloc() override = default;
+};
+
+class GrD3DMemoryAllocator : public SkRefCnt {
+public:
+    virtual gr_cp<ID3D12Resource> createResource(D3D12_HEAP_TYPE, const D3D12_RESOURCE_DESC*,
+                                                 D3D12_RESOURCE_STATES initialResourceState,
+                                                 sk_sp<GrD3DAlloc>* allocation,
+                                                 const D3D12_CLEAR_VALUE*) = 0;
+    virtual gr_cp<ID3D12Resource> createAliasingResource(sk_sp<GrD3DAlloc>& allocation,
+                                                         uint64_t localOffset,
+                                                         const D3D12_RESOURCE_DESC*,
+                                                         D3D12_RESOURCE_STATES initialResourceState,
+                                                         const D3D12_CLEAR_VALUE*) = 0;
+};
+
+// Note: there is no notion of Borrowed or Adopted resources in the D3D backend,
+// so Ganesh will ref fResource once it's asked to wrap it.
+// Clients are responsible for releasing their own ref to avoid memory leaks.
+struct GrD3DTextureResourceInfo {
+    gr_cp<ID3D12Resource>    fResource             = nullptr;
+    sk_sp<GrD3DAlloc>        fAlloc                = nullptr;
+    D3D12_RESOURCE_STATES    fResourceState        = D3D12_RESOURCE_STATE_COMMON;
+    DXGI_FORMAT              fFormat               = DXGI_FORMAT_UNKNOWN;
+    uint32_t                 fSampleCount          = 1;
+    uint32_t                 fLevelCount           = 0;
+    unsigned int             fSampleQualityPattern = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
+    GrProtected              fProtected            = GrProtected::kNo;
+
+    GrD3DTextureResourceInfo() = default;
+
+    GrD3DTextureResourceInfo(ID3D12Resource* resource,
+                             const sk_sp<GrD3DAlloc> alloc,
+                             D3D12_RESOURCE_STATES resourceState,
+                             DXGI_FORMAT format,
+                             uint32_t sampleCount,
+                             uint32_t levelCount,
+                             unsigned int sampleQualityLevel,
+                             GrProtected isProtected = GrProtected::kNo)
+            : fResource(resource)
+            , fAlloc(alloc)
+            , fResourceState(resourceState)
+            , fFormat(format)
+            , fSampleCount(sampleCount)
+            , fLevelCount(levelCount)
+            , fSampleQualityPattern(sampleQualityLevel)
+            , fProtected(isProtected) {}
+
+    GrD3DTextureResourceInfo(const GrD3DTextureResourceInfo& info,
+                             D3D12_RESOURCE_STATES resourceState)
+            : fResource(info.fResource)
+            , fAlloc(info.fAlloc)
+            , fResourceState(resourceState)
+            , fFormat(info.fFormat)
+            , fSampleCount(info.fSampleCount)
+            , fLevelCount(info.fLevelCount)
+            , fSampleQualityPattern(info.fSampleQualityPattern)
+            , fProtected(info.fProtected) {}
+
+#if GR_TEST_UTILS
+    bool operator==(const GrD3DTextureResourceInfo& that) const {
+        return fResource == that.fResource && fResourceState == that.fResourceState &&
+               fFormat == that.fFormat && fSampleCount == that.fSampleCount &&
+               fLevelCount == that.fLevelCount &&
+               fSampleQualityPattern == that.fSampleQualityPattern && fProtected == that.fProtected;
+    }
+#endif
+};
+
+struct GrD3DFenceInfo {
+    GrD3DFenceInfo()
+        : fFence(nullptr)
+        , fValue(0) {
+    }
+
+    gr_cp<ID3D12Fence> fFence;
+    uint64_t           fValue;  // signal value for the fence
+};
+
+struct GrD3DSurfaceInfo {
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+    GrProtected fProtected = GrProtected::kNo;
+
+    DXGI_FORMAT fFormat = DXGI_FORMAT_UNKNOWN;
+    unsigned int fSampleQualityPattern = DXGI_STANDARD_MULTISAMPLE_QUALITY_PATTERN;
+};
+
+#endif