@shopify/react-native-skia 0.1.158 → 0.1.159

package/cpp/skia/include/gpu/graphite/Recorder.h

@@ -9,33 +9,56 @@
 #define skgpu_graphite_Recorder_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
 #include "include/private/SingleOwner.h"
+#include "include/private/SkTHash.h"
 
 #include <vector>
 
+class SkPixmap;
+class SkRuntimeEffectDictionary;
 class SkTextureDataBlock;
 class SkUniformDataBlock;
-class SkUniformDataBlockPassThrough;  // TODO: remove
+
+namespace skgpu { class TokenTracker; }
+
+namespace sktext::gpu {
+class StrikeCache;
+class TextBlobRedrawCoordinator;
+}
 
 namespace skgpu::graphite {
 
+class AtlasManager;
+class BackendTexture;
 class Caps;
 class Device;
 class DrawBufferManager;
 class GlobalCache;
-class Gpu;
+class ImageProvider;
 class RecorderPriv;
 class Recording;
 class ResourceProvider;
+class SharedContext;
 class Task;
 class TaskGraph;
+class TextureInfo;
 class UploadBufferManager;
 
-template<typename StorageT, typename BaseT> class PipelineDataCache;
-using UniformDataCache = PipelineDataCache<SkUniformDataBlockPassThrough, SkUniformDataBlock>;
-using TextureDataCache = PipelineDataCache<std::unique_ptr<SkTextureDataBlock>, SkTextureDataBlock>;
+template<typename T> class PipelineDataCache;
+using UniformDataCache = PipelineDataCache<SkUniformDataBlock>;
+using TextureDataCache = PipelineDataCache<SkTextureDataBlock>;
+
+struct SK_API RecorderOptions final {
+    RecorderOptions();
+    RecorderOptions(const RecorderOptions&);
+    ~RecorderOptions();
+
+    sk_sp<ImageProvider> fImageProvider;
+};
 
-class Recorder final {
+class SK_API Recorder final {
 public:
     Recorder(const Recorder&) = delete;
     Recorder(Recorder&&) = delete;
@@ -46,6 +69,52 @@ public:
 
     std::unique_ptr<Recording> snap();
 
+    ImageProvider* clientImageProvider() { return fClientImageProvider.get(); }
+    const ImageProvider* clientImageProvider() const { return fClientImageProvider.get(); }
+
+    /**
+     * Creates a new backend gpu texture matching the dimensions and TextureInfo. If an invalid
+     * TextureInfo or a TextureInfo Skia can't support is passed in, this will return an invalid
+     * BackendTexture. Thus the client should check isValid on the returned BackendTexture to know
+     * if it succeeded or not.
+     *
+     * If this does return a valid BackendTexture, the caller is required to use
+     * Recorder::deleteBackendTexture or Context::deleteBackendTexture to delete the texture. It is
+     * safe to use the Context that created this Recorder or any other Recorder created from the
+     * same Context to call deleteBackendTexture.
+     */
+    BackendTexture createBackendTexture(SkISize dimensions, const TextureInfo&);
+
+    /**
+     * If possible, updates a backend texture with the provided pixmap data. The client
+     * should check the return value to see if the update was successful. The client is required
+     * to insert a Recording into the Context and call `submit` to send the upload work to the gpu.
+     * The backend texture must be compatible with the provided pixmap(s). Compatible, in this case,
+     * means that the backend format is compatible with the base pixmap's colortype. The src data
+     * can be deleted when this call returns.
+     * If the backend texture is mip mapped, the data for all the mipmap levels must be provided.
+     * In the mipmapped case all the colortypes of the provided pixmaps must be the same.
+     * Additionally, all the miplevels must be sized correctly (please see
+     * SkMipmap::ComputeLevelSize and ComputeLevelCount).
+     * Note: the pixmap's alphatypes and colorspaces are ignored.
+     * For the Vulkan backend after a successful update the layout of the created VkImage will be:
+     *      VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL
+     */
+    bool updateBackendTexture(const BackendTexture&,
+                              const SkPixmap srcData[],
+                              int numLevels);
+
+    /**
+     * Called to delete the passed in BackendTexture. This should only be called if the
+     * BackendTexture was created by calling Recorder::createBackendTexture on a Recorder that is
+     * associated with the same Context. If the BackendTexture is not valid or does not match the
+     * BackendApi of the Recorder then nothing happens.
+     *
+     * Otherwise this will delete/release the backend object that is wrapped in the BackendTexture.
+     * The BackendTexture will be reset to an invalid state and should not be used again.
+     */
+    void deleteBackendTexture(BackendTexture&);
+
     // Provides access to functions that aren't part of the public API.
     RecorderPriv priv();
     const RecorderPriv priv() const;  // NOLINT(readability-const-return-type)
@@ -59,10 +128,12 @@ private:
     friend class Device; // For registering and deregistering Devices;
     friend class RecorderPriv; // for ctor and hidden methods
 
-    Recorder(sk_sp<Gpu>, sk_sp<GlobalCache>);
+    Recorder(sk_sp<SharedContext>, const RecorderOptions&);
 
     SingleOwner* singleOwner() const { return &fSingleOwner; }
 
+    BackendApi backend() const;
+
     // We keep track of all Devices that are connected to a Recorder. This allows the client to
     // safely delete an SkSurface or a Recorder in any order. If the client deletes the Recorder
     // we need to notify all Devices that the Recorder is no longer valid. If we delete the
@@ -83,8 +154,9 @@ private:
     void registerDevice(Device*);
     void deregisterDevice(const Device*);
 
-    sk_sp<Gpu> fGpu;
+    sk_sp<SharedContext> fSharedContext;
     std::unique_ptr<ResourceProvider> fResourceProvider;
+    std::unique_ptr<SkRuntimeEffectDictionary> fRuntimeEffectDict;
 
     std::unique_ptr<TaskGraph> fGraph;
     std::unique_ptr<UniformDataCache> fUniformDataCache;
@@ -93,6 +165,13 @@ private:
     std::unique_ptr<UploadBufferManager> fUploadBufferManager;
     std::vector<Device*> fTrackedDevices;
 
+    uint32_t fRecorderID;  // Needed for MessageBox handling for text
+    std::unique_ptr<AtlasManager> fAtlasManager;
+    std::unique_ptr<TokenTracker> fTokenTracker;
+    std::unique_ptr<sktext::gpu::StrikeCache> fStrikeCache;
+    std::unique_ptr<sktext::gpu::TextBlobRedrawCoordinator> fTextBlobCache;
+    sk_sp<ImageProvider> fClientImageProvider;
+
     // In debug builds we guard against improper thread handling
     // This guard is passed to the ResourceCache.
     // TODO: Should we also pass this to Device, DrawContext, and similar classes?

package/cpp/skia/include/gpu/graphite/Recording.h

@@ -10,28 +10,38 @@
 
 #include "include/core/SkRefCnt.h"
 
-class SkTextureDataBlock;
+#include <memory>
+#include <vector>
 
 namespace skgpu::graphite {
 
 class CommandBuffer;
-template<typename StorageT, typename BaseT> class PipelineDataCache;
-using TextureDataCache = PipelineDataCache<std::unique_ptr<SkTextureDataBlock>, SkTextureDataBlock>;
+class RecordingPriv;
+class Resource;
+class ResourceProvider;
+class TaskGraph;
 
 class Recording final {
 public:
     ~Recording();
 
-protected:
+    RecordingPriv priv();
+
 private:
-    friend class Context; // for access fCommandBuffer
     friend class Recorder; // for ctor
-    Recording(sk_sp<CommandBuffer>, std::unique_ptr<TextureDataCache>);
+    friend class RecordingPriv;
+
+    Recording(std::unique_ptr<TaskGraph>);
 
-    sk_sp<CommandBuffer> fCommandBuffer;
+    bool addCommands(CommandBuffer*, ResourceProvider*);
+    void addResourceRef(sk_sp<Resource>);
 
-    // The TextureDataCache holds all the Textures and Samplers used in this Recording.
-    std::unique_ptr<TextureDataCache> fTextureDataCache;
+    std::unique_ptr<TaskGraph> fGraph;
+    // We don't always take refs to all resources used by specific Tasks (e.g. a common buffer used
+    // for uploads). Instead we'll just hold onto one ref for those Resources outside the Tasks.
+    // Those refs are stored in the array here and will eventually be passed onto a CommandBuffer
+    // when the Recording adds its commands.
+    std::vector<sk_sp<Resource>> fExtraResourceRefs;
 };
 
 } // namespace skgpu::graphite

package/cpp/skia/include/gpu/graphite/TextureInfo.h

@@ -14,16 +14,12 @@
 #include "include/private/gpu/graphite/MtlTypesPriv.h"
 #endif
 
-namespace skgpu::graphite {
-
-// Forward declares so we can friend classes in other namespaces
-#ifdef SK_METAL
-namespace graphite {
-    class MtlCaps;
-    class MtlTexture;
-}
+#ifdef SK_VULKAN
+#include "include/private/gpu/graphite/VulkanGraphiteTypesPriv.h"
 #endif
 
+namespace skgpu::graphite {
+
 class TextureInfo {
 public:
     TextureInfo() {}
@@ -37,6 +33,20 @@ public:
             , fMtlSpec(mtlInfo) {}
 #endif
 
+#ifdef SK_VULKAN
+    TextureInfo(const VulkanTextureInfo& vkInfo)
+            : fBackend(BackendApi::kVulkan)
+            , fValid(true)
+            , fSampleCount(vkInfo.fSampleCount)
+            , fLevelCount(vkInfo.fLevelCount)
+            , fProtected(Protected::kNo)
+            , fVkSpec(vkInfo) {
+        if (vkInfo.fFlags & VK_IMAGE_CREATE_PROTECTED_BIT) {
+            fProtected = Protected::kYes;
+        }
+    }
+#endif
+
     ~TextureInfo() {}
     TextureInfo(const TextureInfo&) = default;
     TextureInfo& operator=(const TextureInfo&);
@@ -61,6 +71,16 @@ public:
     }
 #endif
 
+#ifdef SK_VULKAN
+    bool getVulkanTextureInfo(VulkanTextureInfo* info) const {
+        if (!this->isValid() || fBackend != BackendApi::kVulkan) {
+            return false;
+        }
+        *info = VulkanTextureSpecToTextureInfo(fVkSpec, fSampleCount, fLevelCount);
+        return true;
+    }
+#endif
+
 private:
 #ifdef SK_METAL
     friend class MtlCaps;
@@ -72,6 +92,15 @@ private:
     }
 #endif
 
+#ifdef SK_VULKAN
+    friend class VulkanCaps;
+    friend class VulkanTexture;
+    const VulkanTextureSpec& vulkanTextureSpec() const {
+        SkASSERT(fValid && fBackend == BackendApi::kVulkan);
+        return fVkSpec;
+    }
+#endif
+
     BackendApi fBackend = BackendApi::kMock;
     bool fValid = false;
 
@@ -82,6 +111,9 @@ private:
     union {
 #ifdef SK_METAL
         MtlTextureSpec fMtlSpec;
+#endif
+#ifdef SK_VULKAN
+        VulkanTextureSpec fVkSpec;
 #endif
     };
 };

package/cpp/skia/include/gpu/graphite/dawn/DawnBackendContext.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2022 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_DawnBackendContext_DEFINED
+#define skgpu_graphite_DawnBackendContext_DEFINED
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace skgpu::graphite {
+
+// The DawnBackendContext contains all of the base Dawn objects needed by the graphite Dawn
+// backend. The client will create this object and pass it into the Context::MakeDawn factory call
+// when setting up Skia.
+struct SK_API DawnBackendContext {
+    wgpu::Device fDevice;
+    wgpu::Queue  fQueue;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_DawnBackendContext_DEFINED

package/cpp/skia/include/gpu/graphite/mtl/MtlBackendContext.h

@@ -12,8 +12,9 @@
 
 namespace skgpu::graphite {
 
-// The MtlBackendContext contains all of the base Metal objects needed by the MtlGpu. The assumption
-// is that the client will set these up and pass them to the MtlGpu constructor.
+// The MtlBackendContext contains all of the base Metal objects needed by the graphite Metal
+// backend. The client will create this object and pass it into the Context::MakeMetal factory call
+// when setting up Skia.
 struct SK_API MtlBackendContext {
     sk_cfp<CFTypeRef> fDevice;
     sk_cfp<CFTypeRef> fQueue;

package/cpp/skia/include/gpu/graphite/vk/VulkanGraphiteTypes.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2022 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_VulkanGraphiteTypes_DEFINED
+#define skgpu_graphite_VulkanGraphiteTypes_DEFINED
+
+#include "include/gpu/vk/VulkanTypes.h"
+
+namespace skgpu::graphite {
+
+struct VulkanTextureInfo {
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+
+    // VkImageCreateInfo properties
+    // Currently the only supported flag is VK_IMAGE_CREATE_PROTECTED_BIT. Any other flag will not
+    // be accepted
+    VkImageCreateFlags       fFlags = 0;
+    VkFormat                 fFormat = VK_FORMAT_UNDEFINED;
+    VkImageTiling            fImageTiling = VK_IMAGE_TILING_OPTIMAL;
+    VkImageUsageFlags        fImageUsageFlags = 0;
+    VkSharingMode            fSharingMode = VK_SHARING_MODE_EXCLUSIVE;
+    uint32_t                 fCurrentQueueFamily = VK_QUEUE_FAMILY_IGNORED;
+    VkImageLayout            fImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
+
+    // Properties related to the image view and sampling. These are less inherent properties of the
+    // VkImage but describe how the VkImage should be used within Skia.
+
+    // What aspect to use for the VkImageView. The normal, default is VK_IMAGE_ASPECT_COLOR_BIT.
+    // However, if the VkImage is a Ycbcr format, the client can pass a specific plan here to have
+    // Skia directly sample a plane. In that case the client should also pass in a VkFormat that is
+    // compatible with the plane as described by the Vulkan spec.
+    VkImageAspectFlags fAspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    // TODO: Either Make the ycbcr conversion info shareable with Ganesh or add a version for
+    // Graphite.
+    // GrVkYcbcrConversionInfo  fYcbcrConversionInfo;
+
+    VulkanTextureInfo() = default;
+    VulkanTextureInfo(uint32_t sampleCount,
+                      uint32_t levelCount,
+                      VkImageCreateFlags flags,
+                      VkFormat format,
+                      VkImageTiling imageTiling,
+                      VkImageUsageFlags imageUsageFlags,
+                      VkSharingMode sharingMode,
+                      uint32_t currentQueueFamily,
+                      VkImageLayout imageLayout,
+                      VkImageAspectFlags aspectMask)
+            : fSampleCount(sampleCount)
+            , fLevelCount(levelCount)
+            , fFlags(flags)
+            , fFormat(format)
+            , fImageTiling(imageTiling)
+            , fImageUsageFlags(imageUsageFlags)
+            , fSharingMode(sharingMode)
+            , fCurrentQueueFamily(currentQueueFamily)
+            , fImageLayout(imageLayout)
+            , fAspectMask(aspectMask) {}
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_VulkanGraphiteTypes_DEFINED
+
+

package/cpp/skia/include/gpu/mtl/MtlMemoryAllocator.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2022 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_MtlMemoryAllocator_DEFINED
+#define skgpu_MtlMemoryAllocator_DEFINED
+
+#ifdef __APPLE__
+
+#ifdef __OBJC__
+#import <Metal/Metal.h>
+#endif
+
+namespace skgpu {
+
+// interface classes for the GPU memory allocator
+class MtlAlloc : public SkRefCnt {
+public:
+    ~MtlAlloc() override = default;
+};
+
+#ifdef __OBJC__
+class MtlMemoryAllocator : public SkRefCnt {
+public:
+    virtual id<MTLBuffer> newBufferWithLength(NSUInteger length, MTLResourceOptions options,
+                                              sk_sp<MtlAlloc>* allocation) = 0;
+    virtual id<MTLTexture> newTextureWithDescriptor(MTLTextureDescriptor* texDesc,
+                                                    sk_sp<MtlAlloc>* allocation) = 0;
+};
+#endif
+
+}  // namespace skgpu
+
+#endif // __APPLE__
+
+#endif // skgpu_MtlMemoryAllocator_DEFINED

package/cpp/skia/include/gpu/vk/GrVkBackendContext.h

@@ -9,10 +9,10 @@
 #define GrVkBackendContext_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/gpu/vk/GrVkMemoryAllocator.h"
 #include "include/gpu/vk/GrVkTypes.h"
+#include "include/gpu/vk/VulkanMemoryAllocator.h"
 
-class GrVkExtensions;
+namespace skgpu { class VulkanExtensions; }
 
 enum GrVkExtensionFlags {
     kEXT_debug_report_GrVkExtensionFlag    = 0x0001,
@@ -43,34 +43,36 @@ struct VkPhysicalDeviceFeatures2;
 // (either by deleting the struct or manually releasing the refs) before the underlying vulkan
 // device and instance are destroyed.
 struct SK_API GrVkBackendContext {
-    VkInstance                       fInstance;
-    VkPhysicalDevice                 fPhysicalDevice;
-    VkDevice                         fDevice;
-    VkQueue                          fQueue;
-    uint32_t                         fGraphicsQueueIndex;
-    uint32_t                         fMinAPIVersion; // Deprecated. Set fInstanceVersion instead.
-    uint32_t                         fInstanceVersion = 0; // Deprecated. Set fMaxApiVersion instead
+    VkInstance                          fInstance = VK_NULL_HANDLE;
+    VkPhysicalDevice                    fPhysicalDevice = VK_NULL_HANDLE;
+    VkDevice                            fDevice = VK_NULL_HANDLE;
+    VkQueue                             fQueue = VK_NULL_HANDLE;
+    uint32_t                            fGraphicsQueueIndex = 0;
+    uint32_t                            fMinAPIVersion = 0; // Deprecated. Use fInstanceVersion
+                                                            // instead.
+    uint32_t                            fInstanceVersion = 0; // Deprecated. Use fMaxApiVersion
     // The max api version set here should match the value set in VkApplicationInfo::apiVersion when
     // then VkInstance was created.
-    uint32_t                         fMaxAPIVersion = 0;
-    uint32_t                         fExtensions = 0; // Deprecated. Use fVkExtensions instead.
-    const GrVkExtensions*            fVkExtensions = nullptr;
-    uint32_t                         fFeatures; // Deprecated. Use fDeviceFeatures[2] instead.
+    uint32_t                            fMaxAPIVersion = 0;
+    uint32_t                            fExtensions = 0; // Deprecated. Use fVkExtensions instead.
+    const skgpu::VulkanExtensions*      fVkExtensions = nullptr;
+    uint32_t                            fFeatures = 0; // Deprecated. Use fDeviceFeatures[2]
+                                                       // instead.
     // The client can create their VkDevice with either a VkPhysicalDeviceFeatures or
     // VkPhysicalDeviceFeatures2 struct, thus we have to support taking both. The
     // VkPhysicalDeviceFeatures2 struct is needed so we know if the client enabled any extension
     // specific features. If fDeviceFeatures2 is not null then we ignore fDeviceFeatures. If both
     // fDeviceFeatures and fDeviceFeatures2 are null we will assume no features are enabled.
-    const VkPhysicalDeviceFeatures*  fDeviceFeatures = nullptr;
-    const VkPhysicalDeviceFeatures2* fDeviceFeatures2 = nullptr;
-    sk_sp<GrVkMemoryAllocator>       fMemoryAllocator;
-    GrVkGetProc                      fGetProc = nullptr;
+    const VkPhysicalDeviceFeatures*     fDeviceFeatures = nullptr;
+    const VkPhysicalDeviceFeatures2*    fDeviceFeatures2 = nullptr;
+    sk_sp<skgpu::VulkanMemoryAllocator> fMemoryAllocator;
+    skgpu::VulkanGetProc                fGetProc = nullptr;
     // This is deprecated and should be set to false. The client is responsible for managing the
     // lifetime of the VkInstance and VkDevice objects.
-    bool                             fOwnsInstanceAndDevice = false;
+    bool                                fOwnsInstanceAndDevice = false;
     // Indicates that we are working with protected content and all CommandPool and Queue operations
     // should be done in a protected context.
-    GrProtected                      fProtectedContext = GrProtected::kNo;
+    GrProtected                         fProtectedContext = GrProtected::kNo;
 };
 
 #endif

package/cpp/skia/include/gpu/vk/GrVkExtensions.h

@@ -8,56 +8,8 @@
 #ifndef GrVkExtensions_DEFINED
 #define GrVkExtensions_DEFINED
 
-#include "include/core/SkString.h"
-#include "include/gpu/vk/GrVkTypes.h"
-#include "include/private/SkTArray.h"
+#include "include/gpu/vk/VulkanExtensions.h"
 
-/**
- * Helper class that eats in an array of extensions strings for instance and device and allows for
- * quicker querying if an extension is present.
- */
-class SK_API GrVkExtensions {
-public:
-    GrVkExtensions() {}
-
-    void init(GrVkGetProc, VkInstance, VkPhysicalDevice,
-              uint32_t instanceExtensionCount, const char* const* instanceExtensions,
-              uint32_t deviceExtensionCount, const char* const* deviceExtensions);
-
-    bool hasExtension(const char[], uint32_t minVersion) const;
-
-    struct Info {
-        Info() {}
-        Info(const char* name) : fName(name), fSpecVersion(0) {}
-
-        SkString fName;
-        uint32_t fSpecVersion;
-
-        struct Less {
-            bool operator()(const Info& a, const SkString& b) const {
-                return strcmp(a.fName.c_str(), b.c_str()) < 0;
-            }
-            bool operator()(const SkString& a, const GrVkExtensions::Info& b) const {
-                return strcmp(a.c_str(), b.fName.c_str()) < 0;
-            }
-        };
-    };
-
-#ifdef SK_DEBUG
-    void dump() const {
-        SkDebugf("**Vulkan Extensions**\n");
-        for (int i = 0; i < fExtensions.count(); ++i) {
-            SkDebugf("%s. Version: %d\n",
-                     fExtensions[i].fName.c_str(), fExtensions[i].fSpecVersion);
-        }
-        SkDebugf("**End Vulkan Extensions**\n");
-    }
-#endif
-
-private:
-    void getSpecVersions(GrVkGetProc getProc, VkInstance, VkPhysicalDevice);
-
-    SkTArray<Info>  fExtensions;
-};
+using GrVkExtensions = skgpu::VulkanExtensions;
 
 #endif