rngine 0.7.2 → 0.8.1

package/shared/skia/include/gpu/vk/VulkanExtensions.h

@@ -0,0 +1,73 @@
+/*
+ * 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_VulkanExtensions_DEFINED
+#define skgpu_VulkanExtensions_DEFINED
+
+#include "include/core/SkString.h"
+#include "include/gpu/vk/VulkanTypes.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkDebug.h"
+#include "include/private/SkTArray.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+#include <cstring>
+
+namespace skgpu {
+
+/**
+ * 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 VulkanExtensions {
+public:
+    VulkanExtensions() {}
+
+    void init(VulkanGetProc, 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() {}
+        explicit 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 std::strcmp(a.fName.c_str(), b.c_str()) < 0;
+            }
+            bool operator()(const SkString& a, const VulkanExtensions::Info& b) const {
+                return std::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.size(); ++i) {
+            SkDebugf("%s. Version: %u\n",
+                     fExtensions[i].fName.c_str(), fExtensions[i].fSpecVersion);
+        }
+        SkDebugf("**End Vulkan Extensions**\n");
+    }
+#endif
+
+private:
+    void getSpecVersions(const VulkanGetProc& getProc, VkInstance, VkPhysicalDevice);
+
+    skia_private::TArray<Info> fExtensions;
+};
+
+} // namespace skgpu
+
+#endif // skgpu_VulkanExtensions_DEFINED

package/shared/skia/include/gpu/vk/VulkanMemoryAllocator.h

@@ -0,0 +1,117 @@
+/*
+ * 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_VulkanMemoryAllocator_DEFINED
+#define skgpu_VulkanMemoryAllocator_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/vk/VulkanTypes.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+#include <utility>
+
+namespace skgpu {
+
+class VulkanMemoryAllocator : public SkRefCnt {
+public:
+    enum AllocationPropertyFlags {
+        kNone_AllocationPropertyFlag                = 0b0000,
+        // Allocation will be placed in its own VkDeviceMemory and not suballocated from some larger
+        // block.
+        kDedicatedAllocation_AllocationPropertyFlag = 0b0001,
+        // Says that the backing memory can only be accessed by the device. Additionally the device
+        // may lazily allocate the memory. This cannot be used with buffers that will be host
+        // visible. Setting this flag does not guarantee that we will allocate memory that respects
+        // it, but we will try to prefer memory that can respect it.
+        kLazyAllocation_AllocationPropertyFlag      = 0b0010,
+        // The allocation will be mapped immediately and stay mapped until it is destroyed. This
+        // flag is only valid for buffers which are host visible (i.e. must have a usage other than
+        // BufferUsage::kGpuOnly).
+        kPersistentlyMapped_AllocationPropertyFlag  = 0b0100,
+        // Allocation can only be accessed by the device using a protected context.
+        kProtected_AllocationPropertyFlag           = 0b1000,
+    };
+
+    enum class BufferUsage {
+        // Buffers that will only be accessed from the device (large const buffers) will always be
+        // in device local memory.
+        kGpuOnly,
+        // Buffers that typically will be updated multiple times by the host and read on the gpu
+        // (e.g. uniform or vertex buffers). CPU writes will generally be sequential in the buffer
+        // and will try to take advantage of the write-combined nature of the gpu buffers. Thus this
+        // will always be mappable and coherent memory, and it will prefer to be in device local
+        // memory.
+        kCpuWritesGpuReads,
+        // Buffers that will be accessed on the host and copied to another GPU resource (transfer
+        // buffers). Will always be mappable and coherent memory.
+        kTransfersFromCpuToGpu,
+        // Buffers which are typically writted to by the GPU and then read on the host. Will always
+        // be mappable memory, and will prefer cached memory.
+        kTransfersFromGpuToCpu,
+    };
+
+    virtual VkResult allocateImageMemory(VkImage image,
+                                         uint32_t allocationPropertyFlags,
+                                         skgpu::VulkanBackendMemory* memory) = 0;
+
+    virtual VkResult allocateBufferMemory(VkBuffer buffer,
+                                          BufferUsage usage,
+                                          uint32_t allocationPropertyFlags,
+                                          skgpu::VulkanBackendMemory* memory) = 0;
+
+    // Fills out the passed in skgpu::VulkanAlloc struct for the passed in
+    // skgpu::VulkanBackendMemory.
+    virtual void getAllocInfo(const skgpu::VulkanBackendMemory&, skgpu::VulkanAlloc*) const = 0;
+
+    // Maps the entire allocation and returns a pointer to the start of the allocation. The
+    // implementation may map more memory than just the allocation, but the returned pointer must
+    // point at the start of the memory for the requested allocation.
+    virtual void* mapMemory(const skgpu::VulkanBackendMemory&) { return nullptr; }
+    virtual VkResult mapMemory(const skgpu::VulkanBackendMemory& memory, void** data) {
+        *data = this->mapMemory(memory);
+        // VK_ERROR_INITIALIZATION_FAILED is a bogus result to return from this function, but it is
+        // just something to return that is not VK_SUCCESS and can't be interpreted by a caller to
+        // mean something specific happened like device lost or oom. This will be removed once we
+        // update clients to implement this virtual.
+        return *data ? VK_SUCCESS : VK_ERROR_INITIALIZATION_FAILED;
+    }
+    virtual void unmapMemory(const skgpu::VulkanBackendMemory&) = 0;
+
+    // The following two calls are used for managing non-coherent memory. The offset is relative to
+    // the start of the allocation and not the underlying VkDeviceMemory. Additionaly the client
+    // must make sure that the offset + size passed in is less that or equal to the allocation size.
+    // It is the responsibility of the implementation to make sure all alignment requirements are
+    // followed. The client should not have to deal with any sort of alignment issues.
+    virtual void flushMappedMemory(const skgpu::VulkanBackendMemory&, VkDeviceSize, VkDeviceSize) {}
+    virtual VkResult flushMemory(const skgpu::VulkanBackendMemory& memory,
+                                 VkDeviceSize offset,
+                                 VkDeviceSize size) {
+        this->flushMappedMemory(memory, offset, size);
+        return VK_SUCCESS;
+    }
+    virtual void invalidateMappedMemory(const skgpu::VulkanBackendMemory&,
+                                        VkDeviceSize,
+                                        VkDeviceSize) {}
+    virtual VkResult invalidateMemory(const skgpu::VulkanBackendMemory& memory,
+                                      VkDeviceSize offset,
+                                      VkDeviceSize size) {
+        this->invalidateMappedMemory(memory, offset, size);
+        return VK_SUCCESS;
+    }
+
+    virtual void freeMemory(const skgpu::VulkanBackendMemory&) = 0;
+
+    // Returns the total amount of memory that is allocated as well as total
+    // amount of memory in use by an allocation from this allocator.
+    // Return 1st param is total allocated memory, 2nd is total used memory.
+    virtual std::pair<uint64_t, uint64_t> totalAllocatedAndUsedMemory() const = 0;
+};
+
+} // namespace skgpu
+
+#endif // skgpu_VulkanMemoryAllocator_DEFINED

package/shared/skia/include/gpu/vk/VulkanMutableTextureState.h

@@ -0,0 +1,26 @@
+/*
+ * 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_VulkanMutableTextureState_DEFINED
+#define skgpu_VulkanMutableTextureState_DEFINED
+
+#include "include/gpu/MutableTextureState.h"
+#include "include/private/SkAPI.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstdint>
+
+namespace skgpu::MutableTextureStates {
+SK_API MutableTextureState MakeVulkan(VkImageLayout layout, uint32_t queueFamilyIndex);
+
+SK_API VkImageLayout GetVkImageLayout(const MutableTextureState& state);
+SK_API VkImageLayout GetVkImageLayout(const MutableTextureState* state);
+SK_API uint32_t GetVkQueueFamilyIndex(const MutableTextureState& state);
+SK_API uint32_t GetVkQueueFamilyIndex(const MutableTextureState* state);
+}
+
+#endif

package/shared/skia/include/gpu/vk/VulkanPreferredFeatures.h

@@ -0,0 +1,225 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_VulkanPreferredFeatures_DEFINED
+#define skgpu_VulkanPreferredFeatures_DEFINED
+
+#include "include/private/SkAPI.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace skgpu {
+
+class SK_API VulkanPreferredFeatures {
+public:
+    ~VulkanPreferredFeatures();
+
+    /*
+     * VulkanPreferredFeatures is used by Skia to add extensions and features on top of what the app
+     * wants to enable. The flow of Vulkan initialization for an app that wants to use Skia would
+     * be:
+     *
+     * ```
+     * // Query the loader for instance information, decide on API version to use
+     *
+     * // Prepare for Skia-enabled extensions and features
+     * skgpu::VulkanPreferredFeatures skiaFeatures;
+     * skiaFeatures.init(apiVersion);
+     *
+     * // Decide on instance extensions to use in the app.
+     *
+     * // Allow Skia to add to the instance extension list.
+     * skiaFeatures.addToInstanceExtensions(...);
+     *
+     * // Create the instance, choose physical device, query available extensions, decide on
+     * // device features to query
+     *
+     * // Allow Skia to add to the feature query list.
+     * skiaFeatures.addFeaturesToQuery(...);
+     *
+     * // Query features, decide on extensions and features to enable.
+     *
+     * // Allow Skia to add to the device extension and feature list.
+     * skiaFeatures.addFeaturesToEnable(...);
+     *
+     * // Create the Vulkan device.
+     * ```
+     *
+     * Parameters:
+     *
+     * * appAPIVersion: The API version the app has specified in VkApplicationInfo::apiVersion (and
+     *   will later provide in VulkanBackendContext::fMaxAPIVersion). The minimum supported version
+     *   is VK_API_VERSION_1_1, maximum is VK_API_VERSION_1_4.
+     */
+    void init(uint32_t appAPIVersion);
+
+    /*
+     * Before creating a Vulkan instance, call addToInstanceExtensions to give Skia a chance to add
+     * instance extensions it may take advantage of. Extensions are only added to appExtensions if
+     * caller hasn't already included them to be enabled.
+     *
+     * Parameters:
+     *
+     * * instanceExtensions, instanceExtensionCount: The list of available instance extensions as
+     *   queried from the loader.
+     * * appExtensions: The list of extensions to be enabled on the instance; more extensions may be
+     *   added to this list by this call.
+     */
+    void addToInstanceExtensions(const VkExtensionProperties* instanceExtensions,
+                                 size_t instanceExtensionCount,
+                                 std::vector<const char*>& appExtensions);
+
+    /*
+     * Before querying Vulkan device features, call addFeaturesToQuery to give Skia a chance to add
+     * device extension features it may take advantage of to the query. Features are only added to
+     * appFeatures if caller hasn't already included them in the query.
+     *
+     * Beware that the structs that get chained to appFeatures are member variables of this class,
+     * so this object must not leave scope until feature query and device creation is complete.
+     *
+     * Parameters:
+     *
+     * * deviceExtensions, deviceExtensionCount: The list of available device extensions as queried
+     *   from the physical device.
+     * * appFeatures: The features to be queried from the physical device; more features may be
+     *   added to the pNext chain by this call.
+     */
+    void addFeaturesToQuery(const VkExtensionProperties* deviceExtensions,
+                            size_t deviceExtensionCount,
+                            VkPhysicalDeviceFeatures2& appFeatures);
+
+    /*
+     * Before creating the Vulkan device, call addFeaturesToEnable to give Skia a chance to add
+     * device extensions and features it may take advantage of. Extensions and features are only
+     * added to appExtensions and appFeatures respectively if caller hasn't already included them to
+     * be enabled. This function may replace chained features with VkPhysicalDeviceVulkanNNFeatures
+     * structs instead in order to add features. Features that are already enabled by the
+     * application are retained in that case in the new struct.
+     *
+     * Parameters:
+     *
+     * * appExtensions: The list of extensions to be enabled on the device; more extensions may be
+     *   added to this list by this call.
+     * * appFeatures: The features to be enabled on the device; more features may be
+     *   added to the pNext chain by this call.
+     */
+    void addFeaturesToEnable(std::vector<const char*>& appExtensions,
+                             VkPhysicalDeviceFeatures2& appFeatures);
+
+private:
+    uint32_t fAPIVersion = 0;
+    // Track what the application did, so warnings can be generated if the class is not
+    // fully/correctly used.
+    bool fHasAddedToInstanceExtensions = false;
+    bool fHasAddedFeaturesToQuery = false;
+    bool fHasAddedFeaturesToEnable = false;
+
+    // The list of device features Skia is interested in. If any are included in
+    // VkPhysicalDeviceFeatures2::pNext by the app, it is not included again by Skia. However, to
+    // take best advantage of the Vulkan API, the app should not intentionally include these feature
+    // structs only to forcefully disable the feature - this blocks Skia from leveraging it.
+    //
+    // When ambiguous, the extension name is included to determine which extension a feature struct
+    // has come from. This is usually needed when addFeaturesToQuery has included a feature struct
+    // that is present in multiple extensions (e.g. due to extension promotion). It is later used by
+    // addFeaturesToEnable to know which extension to enable.
+
+    // Available since Vulkan 1.2
+    VkPhysicalDeviceVulkan11Features fVulkan11 = {};
+
+    // Available since Vulkan 1.2
+    VkPhysicalDeviceVulkan12Features fVulkan12 = {};
+
+    // Available since Vulkan 1.3
+    VkPhysicalDeviceVulkan13Features fVulkan13 = {};
+
+    // Available since Vulkan 1.4
+    VkPhysicalDeviceVulkan14Features fVulkan14 = {};
+
+    // Feature of VK_EXT_rasterization_order_attachment_access or
+    // VK_ARM_rasterization_order_attachment_access.
+    VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT
+            fRasterizationOrderAttachmentAccess = {};
+    const char* fRasterizationOrderAttachmentAccessExtension = nullptr;
+
+    // Feature of VK_EXT_blend_operation_advanced
+    VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT fBlendOperationAdvanced = {};
+
+    // Feature of VK_EXT_extended_dynamic_state
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT fExtendedDynamicState = {};
+
+    // Feature of VK_EXT_extended_dynamic_state2
+    VkPhysicalDeviceExtendedDynamicState2FeaturesEXT fExtendedDynamicState2 = {};
+
+    // Feature of VK_EXT_vertex_input_dynamic_state
+    VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT fVertexInputDynamicState = {};
+
+    // Feature of VK_EXT_graphics_pipeline_library
+    VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT fGraphicsPipelineLibrary = {};
+
+    // Feature of VK_KHR_sampler_ycbcr_conversion or Vulkan 1.1
+    VkPhysicalDeviceSamplerYcbcrConversionFeatures fSamplerYcbcrConversion = {};
+
+    // Feature of VK_EXT_rgba10x6_formats
+    VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT fRGBA10x6Formats = {};
+
+    // Feature of VK_KHR_synchronization2 or Vulkan 1.3
+    VkPhysicalDeviceDynamicRenderingFeatures fSynchronization2 = {};
+
+    // Feature of VK_KHR_dynamic_rendering or Vulkan 1.3
+    VkPhysicalDeviceDynamicRenderingFeatures fDynamicRendering = {};
+
+    // Feature of VK_KHR_dynamic_rendering_local_read or Vulkan 1.4
+    VkPhysicalDeviceDynamicRenderingLocalReadFeatures fDynamicRenderingLocalRead = {};
+
+    // Feature of VK_EXT_multisampled_render_to_single_sampled
+    VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT
+            fMultisampledRenderToSingleSampled = {};
+
+    // Feature of VK_EXT_host_image_copy or Vulkan 1.4
+    VkPhysicalDeviceHostImageCopyFeatures fHostImageCopy = {};
+
+    // Feature of VK_EXT_pipeline_creation_cache_control or Vulkan 1.3
+    VkPhysicalDevicePipelineCreationCacheControlFeatures fPipelineCreationCacheControl = {};
+
+    // Feature of VK_EXT_frame_boundary
+    VkPhysicalDeviceFrameBoundaryFeaturesEXT fFrameBoundary = {};
+
+    // Extensions that don't have a feature:
+    // VK_KHR_driver_properties or Vulkan 1.2
+    const char* fDriverPropertiesExtension = nullptr;
+    // VK_KHR_create_renderpass2 or Vulkan 1.2
+    const char* fCreateRenderpass2Extension = nullptr;
+    // VK_EXT_load_store_op_none, VK_KHR_load_store_op_none or Vulkan 1.4
+    const char* fLoadStoreOpNoneExtension = nullptr;
+    // VK_EXT_conservative_rasterization
+    const char* fConservativeRasterizationExtension = nullptr;
+#if defined(SK_BUILD_FOR_ANDROID)
+    // VK_ANDROID_external_memory_android_hardware_buffer
+    const char* fExternalMemoryAHardwareBufferExtension = nullptr;
+#endif
+
+    // Extensions that the other extensions above depend on:
+    // Dependency of VK_EXT_graphics_pipeline_library: VK_KHR_pipeline_library
+    const char* fPipelineLibraryExtension = nullptr;
+    // Dependencies of VK_EXT_host_image_copy: VK_KHR_copy_commands2, VK_KHR_format_feature_flags2
+    const char* fCopyCommands2Extension = nullptr;
+    const char* fFormatFeatureFlags2Extension = nullptr;
+    // Dependency of VK_EXT_multisampled_render_to_single_sampled: VK_KHR_depth_stencil_resolve
+    const char* fDepthStencilResolveExtension = nullptr;
+#if defined(SK_BUILD_FOR_ANDROID)
+    // Dependency of VK_ANDROID_external_memory_android_hardware_buffer: VK_EXT_queue_family_foreign
+    const char* fQueueFamilyForeignExtension = nullptr;
+#endif
+};
+
+}  // namespace skgpu
+
+#endif  // skgpu_VulkanPreferredFeatures_DEFINED