rngine 0.7.2 → 0.8.1

package/shared/skia/include/gpu/GpuTypes.h

@@ -0,0 +1,98 @@
+/*
+ * 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_GpuTypes_DEFINED
+#define skgpu_GpuTypes_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/private/SkMacros.h"
+
+/**
+ * This file includes numerous public types that are used by all of our gpu backends.
+ */
+
+namespace skgpu {
+
+/**
+ * Possible 3D APIs that may be used by Graphite.
+ */
+enum class BackendApi : unsigned {
+    kDawn,
+    kMetal,
+    kVulkan,
+    kMock,
+
+    /**
+     * Graphite doesn't support some context types (e.g. Direct3D) and will return Unsupported.
+     */
+    kUnsupported,
+};
+
+/** Indicates whether an allocation should count against a cache budget. */
+enum class Budgeted : bool {
+    kNo = false,
+    kYes = true,
+};
+
+/**
+ * Value passed into various callbacks to tell the client the result of operations connected to a
+ * specific callback. The actual interpretation of kFailed and kSuccess are dependent on the
+ * specific callbacks and are documented with the callback itself.
+ */
+enum class CallbackResult : bool {
+    kFailed = false,
+    kSuccess = true,
+};
+
+/**
+ * Is the texture mipmapped or not
+ */
+enum class Mipmapped : bool {
+    kNo = false,
+    kYes = true,
+};
+
+/**
+ * Is the data protected on the GPU or not.
+ */
+enum class Protected : bool {
+    kNo = false,
+    kYes = true,
+};
+
+/**
+ * Is a texture renderable or not
+ */
+enum class Renderable : bool {
+    kNo = false,
+    kYes = true,
+};
+
+/**
+ * What is the logical origin of a BackendTexture passed into Skia
+ */
+enum class Origin : unsigned {
+    kTopLeft,
+    kBottomLeft,
+};
+
+enum class GpuStatsFlags : uint32_t {
+    kNone = 0b00,
+    kElapsedTime = 0b01,
+    kOcclusionPassSamples = 0b10,
+};
+SK_MAKE_BITFIELD_CLASS_OPS(GpuStatsFlags)
+
+struct GpuStats {
+    uint64_t elapsedTime = 0;
+    uint64_t numOcclusionPassSamples = 0;
+};
+
+} // namespace skgpu
+
+
+#endif // skgpu_GpuTypes_DEFINED

package/shared/skia/include/gpu/MutableTextureState.h

@@ -0,0 +1,68 @@
+/*
+ * 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_MutableTextureState_DEFINED
+#define skgpu_MutableTextureState_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkAnySubclass.h"
+
+#include <cstddef>
+
+namespace skgpu {
+enum class BackendApi : unsigned int;
+class MutableTextureStateData;
+
+/**
+ * Since Skia and clients can both modify gpu textures and their connected state, Skia needs a way
+ * for clients to inform us if they have modifiend any of this state. In order to not need setters
+ * for every single API and state, we use this class to be a generic wrapper around all the mutable
+ * state. This class is used for calls that inform Skia of these texture/image state changes by the
+ * client as well as for requesting state changes to be done by Skia. The backend specific state
+ * that is wrapped by this class are located in files like:
+ *   - include/gpu/vk/VulkanMutableTextureState.h
+ */
+class SK_API MutableTextureState : public SkRefCnt {
+public:
+    MutableTextureState();
+    ~MutableTextureState() override;
+
+    MutableTextureState(const MutableTextureState& that);
+
+    MutableTextureState& operator=(const MutableTextureState& that);
+
+    void set(const MutableTextureState& that);
+
+    BackendApi backend() const { return fBackend; }
+
+    // Returns true if the backend mutable state has been initialized.
+    bool isValid() const { return fIsValid; }
+
+private:
+    friend class MutableTextureStateData;
+    friend class MutableTextureStatePriv;
+    // Size determined by looking at the MutableTextureStateData subclasses, then
+    // guessing-and-checking. Compiler will complain if this is too small - in that case,
+    // just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 16;
+    using AnyStateData = SkAnySubclass<MutableTextureStateData, kMaxSubclassSize>;
+
+    template <typename StateData>
+    MutableTextureState(BackendApi api, const StateData& data) : fBackend(api), fIsValid(true) {
+        fStateData.emplace<StateData>(data);
+    }
+
+    AnyStateData fStateData;
+
+    BackendApi fBackend;
+    bool fIsValid;
+};
+
+} // namespace skgpu
+
+#endif // skgpu_MutableTextureState_DEFINED

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

@@ -0,0 +1,46 @@
+/*
+ * 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;
+
+    /**
+     * compileError(shader, errors) is kept for backward compatibility with older clients.
+     */
+    virtual void compileError([[maybe_unused]] const char* shader,
+                              [[maybe_unused]] const char* errors) {}
+    virtual void compileError(const char* shader,
+                              const char* errors,
+                              [[maybe_unused]] bool shaderWasCached) {
+        // Default implementation. Ignore shaderWasCached.
+        this->compileError(shader, errors);
+    }
+
+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/shared/skia/include/gpu/ganesh/GrBackendSemaphore.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef GrBackendSemaphore_DEFINED
+#define GrBackendSemaphore_DEFINED
+
+#include "include/gpu/ganesh/GrTypes.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkAnySubclass.h"
+
+#include <cstddef>
+
+class GrBackendSemaphoreData;
+
+/**
+ * Wrapper class for passing into and receiving data from Ganesh about a backend semaphore object.
+ */
+class SK_API GrBackendSemaphore {
+public:
+    // An empty semaphore. To instantiate, see GrBackendSemaphores::MakeVk and similar
+    GrBackendSemaphore();
+    ~GrBackendSemaphore();
+    GrBackendSemaphore(const GrBackendSemaphore&);
+    GrBackendSemaphore& operator=(const GrBackendSemaphore&);
+
+    GrBackendApi backend() const { return fBackend; }
+    bool isInitialized() const { return fBackend != GrBackendApi::kUnsupported; }
+
+private:
+    friend class GrBackendSemaphorePriv;
+    friend class GrBackendSemaphoreData;
+    // Size determined by looking at the GrBackendSemaphoreData subclasses, then
+    // guessing-and-checking. Compiler will complain if this is too small - in that case,
+    // just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 24;
+    using AnySemaphoreData = SkAnySubclass<GrBackendSemaphoreData, kMaxSubclassSize>;
+
+    template <typename SemaphoreData>
+    GrBackendSemaphore(GrBackendApi api, SemaphoreData data) : fBackend(api) {
+        fSemaphoreData.emplace<SemaphoreData>(data);
+    }
+
+    GrBackendApi fBackend = GrBackendApi::kUnsupported;
+    AnySemaphoreData fSemaphoreData;
+};
+
+#endif

package/shared/skia/include/gpu/ganesh/GrBackendSurface.h

@@ -0,0 +1,257 @@
+/*
+ * Copyright 2017 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrBackendSurface_DEFINED
+#define GrBackendSurface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
+#include "include/private/SkAPI.h"
+#include "include/private/SkAnySubclass.h"
+#include "include/private/SkDebug.h"
+#include "include/private/gpu/ganesh/GrTypesPriv.h"
+
+class GrBackendFormatData;
+class GrBackendTextureData;
+class GrBackendRenderTargetData;
+
+namespace skgpu {
+class MutableTextureState;
+}
+
+#if defined(SK_DEBUG) || defined(GPU_TEST_UTILS)
+class SkString;
+#endif
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+class SK_API GrBackendFormat {
+public:
+    // Creates an invalid backend format.
+    GrBackendFormat();
+    GrBackendFormat(const GrBackendFormat&);
+    GrBackendFormat& operator=(const GrBackendFormat&);
+    ~GrBackendFormat();
+
+    bool operator==(const GrBackendFormat& that) const;
+    bool operator!=(const GrBackendFormat& that) const { return !(*this == that); }
+
+    GrBackendApi backend() const { return fBackend; }
+    GrTextureType textureType() const { return fTextureType; }
+
+    /**
+     * Gets the channels present in the format as a bitfield of SkColorChannelFlag values.
+     * Luminance channels are reported as kGray_SkColorChannelFlag.
+     */
+    uint32_t channelMask() const;
+
+    GrColorFormatDesc desc() const;
+
+    // If possible, copies the GrBackendFormat and forces the texture type to be Texture2D. If the
+    // GrBackendFormat was for Vulkan and it originally had a skgpu::VulkanYcbcrConversionInfo,
+    // we will remove the conversion and set the format to be VK_FORMAT_R8G8B8A8_UNORM.
+    GrBackendFormat makeTexture2D() const;
+
+    // Returns true if the backend format has been initialized.
+    bool isValid() const { return fValid; }
+
+#if defined(SK_DEBUG) || defined(GPU_TEST_UTILS)
+    SkString toStr() const;
+#endif
+
+private:
+    // Size determined by looking at the GrBackendFormatData subclasses, then guessing-and-checking.
+    // Compiler will complain if this is too small - in that case, just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 80;
+    using AnyFormatData = SkAnySubclass<GrBackendFormatData, kMaxSubclassSize>;
+
+    friend class GrBackendSurfacePriv;
+    friend class GrBackendFormatData;
+
+    // Used by internal factories. Should not be used externally. Use factories like
+    // GrBackendFormats::MakeGL instead.
+    template <typename FormatData>
+    GrBackendFormat(GrTextureType textureType, GrBackendApi api, const FormatData& formatData)
+            : fBackend(api), fTextureType(textureType), fValid(true) {
+        fFormatData.emplace<FormatData>(formatData);
+    }
+
+    AnyFormatData fFormatData;
+    GrBackendApi fBackend = GrBackendApi::kUnsupported;
+    GrTextureType fTextureType = GrTextureType::kNone;
+    bool fValid = false;
+};
+
+class SK_API GrBackendTexture {
+public:
+    // Creates an invalid backend texture.
+    GrBackendTexture();
+    GrBackendTexture(const GrBackendTexture& that);
+    ~GrBackendTexture();
+    GrBackendTexture& operator=(const GrBackendTexture& that);
+
+    SkISize dimensions() const { return {fWidth, fHeight}; }
+    int width() const { return fWidth; }
+    int height() const { return fHeight; }
+    std::string_view getLabel() const { return fLabel; }
+    skgpu::Mipmapped mipmapped() const { return fMipmapped; }
+    bool hasMipmaps() const { return fMipmapped == skgpu::Mipmapped::kYes; }
+    GrBackendApi backend() const {return fBackend; }
+    GrTextureType textureType() const { return fTextureType; }
+
+    // Get the GrBackendFormat for this texture (or an invalid format if this is not valid).
+    GrBackendFormat getBackendFormat() const;
+
+    // If the client changes any of the mutable backend of the GrBackendTexture they should call
+    // this function to inform Skia that those values have changed. The backend API specific state
+    // that can be set from this function are:
+    //
+    // Vulkan: VkImageLayout and QueueFamilyIndex
+    void setMutableState(const skgpu::MutableTextureState&);
+
+    // Returns true if we are working with protected content.
+    bool isProtected() const;
+
+    // Returns true if the backend texture has been initialized.
+    bool isValid() const { return fIsValid; }
+
+    // Returns true if both textures are valid and refer to the same API texture.
+    bool isSameTexture(const GrBackendTexture&);
+
+#if defined(GPU_TEST_UTILS)
+    static bool TestingOnly_Equals(const GrBackendTexture&, const GrBackendTexture&);
+#endif
+
+private:
+    // Size determined by looking at the GrBackendTextureData subclasses, then guessing-and-checking.
+    // Compiler will complain if this is too small - in that case, just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 176;
+    using AnyTextureData = SkAnySubclass<GrBackendTextureData, kMaxSubclassSize>;
+
+    friend class GrBackendSurfacePriv;
+    friend class GrBackendTextureData;
+
+    // Used by internal factories. Should not be used externally. Use factories like
+    // GrBackendTextures::MakeGL instead.
+    template <typename TextureData>
+    GrBackendTexture(int width,
+                     int height,
+                     std::string_view label,
+                     skgpu::Mipmapped mipped,
+                     GrBackendApi backend,
+                     GrTextureType texture,
+                     const TextureData& textureData)
+            : fIsValid(true)
+            , fWidth(width)
+            , fHeight(height)
+            , fLabel(label)
+            , fMipmapped(mipped)
+            , fBackend(backend)
+            , fTextureType(texture) {
+        fTextureData.emplace<TextureData>(textureData);
+    }
+
+    friend class GrVkGpu;  // for getMutableState
+    sk_sp<skgpu::MutableTextureState> getMutableState() const;
+
+    bool fIsValid;
+    int fWidth;         //<! width in pixels
+    int fHeight;        //<! height in pixels
+    const std::string fLabel;
+    skgpu::Mipmapped fMipmapped;
+    GrBackendApi fBackend = GrBackendApi::kUnsupported;
+    GrTextureType fTextureType;
+    AnyTextureData fTextureData;
+};
+
+class SK_API GrBackendRenderTarget {
+public:
+    // Creates an invalid backend texture.
+    GrBackendRenderTarget();
+    ~GrBackendRenderTarget();
+    GrBackendRenderTarget(const GrBackendRenderTarget& that);
+    GrBackendRenderTarget& operator=(const GrBackendRenderTarget&);
+
+    SkISize dimensions() const { return {fWidth, fHeight}; }
+    int width() const { return fWidth; }
+    int height() const { return fHeight; }
+    int sampleCnt() const { return fSampleCnt; }
+    int stencilBits() const { return fStencilBits; }
+    GrBackendApi backend() const {return fBackend; }
+    bool isFramebufferOnly() const { return fFramebufferOnly; }
+
+    // Get the GrBackendFormat for this render target (or an invalid format if this is not valid).
+    GrBackendFormat getBackendFormat() const;
+
+    // If the client changes any of the mutable backend of the GrBackendTexture they should call
+    // this function to inform Skia that those values have changed. The backend API specific state
+    // that can be set from this function are:
+    //
+    // Vulkan: VkImageLayout and QueueFamilyIndex
+    void setMutableState(const skgpu::MutableTextureState&);
+
+    // Returns true if we are working with protected content.
+    bool isProtected() const;
+
+    // Returns true if the backend texture has been initialized.
+    bool isValid() const { return fIsValid; }
+
+#if defined(GPU_TEST_UTILS)
+    static bool TestingOnly_Equals(const GrBackendRenderTarget&, const GrBackendRenderTarget&);
+#endif
+
+private:
+    // Size determined by looking at the GrBackendRenderTargetData subclasses, then
+    // guessing-and-checking. Compiler will complain if this is too small - in that case, just
+    // increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 176;
+    using AnyRenderTargetData = SkAnySubclass<GrBackendRenderTargetData, kMaxSubclassSize>;
+
+    friend class GrBackendSurfacePriv;
+    friend class GrBackendRenderTargetData;
+
+    // Used by internal factories. Should not be used externally. Use factories like
+    // GrBackendRenderTargets::MakeGL instead.
+    template <typename RenderTargetData>
+    GrBackendRenderTarget(int width,
+                          int height,
+                          int sampleCnt,
+                          int stencilBits,
+                          GrBackendApi backend,
+                          bool framebufferOnly,
+                          const RenderTargetData& rtData)
+            : fIsValid(true)
+            , fFramebufferOnly(framebufferOnly)
+            , fWidth(width)
+            , fHeight(height)
+            , fSampleCnt(sampleCnt)
+            , fStencilBits(stencilBits)
+            , fBackend(backend) {
+        fRTData.emplace<RenderTargetData>(rtData);
+    }
+
+    friend class GrVkGpu; // for getMutableState
+    sk_sp<skgpu::MutableTextureState> getMutableState() const;
+
+    bool fIsValid;
+    bool fFramebufferOnly = false;
+    int fWidth;         //<! width in pixels
+    int fHeight;        //<! height in pixels
+
+    int fSampleCnt;
+    int fStencilBits;
+
+    GrBackendApi fBackend = GrBackendApi::kUnsupported;
+    AnyRenderTargetData fRTData;
+};
+
+#endif