@pompadour/react-native-skia 1.4.0

package/cpp/skia/include/gpu/gl/GrGLTypes.h

@@ -0,0 +1,219 @@
+
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrGLTypes_DEFINED
+#define GrGLTypes_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/gl/GrGLConfig.h"
+
+/**
+ * Classifies GL contexts by which standard they implement (currently as OpenGL vs. OpenGL ES).
+ */
+enum GrGLStandard {
+    kNone_GrGLStandard,
+    kGL_GrGLStandard,
+    kGLES_GrGLStandard,
+    kWebGL_GrGLStandard,
+};
+static const int kGrGLStandardCnt = 4;
+
+// The following allow certain interfaces to be turned off at compile time
+// (for example, to lower code size).
+#if SK_ASSUME_GL_ES
+    #define GR_IS_GR_GL(standard) false
+    #define GR_IS_GR_GL_ES(standard) true
+    #define GR_IS_GR_WEBGL(standard) false
+    #define SK_DISABLE_GL_INTERFACE 1
+    #define SK_DISABLE_WEBGL_INTERFACE 1
+#elif SK_ASSUME_GL
+    #define GR_IS_GR_GL(standard) true
+    #define GR_IS_GR_GL_ES(standard) false
+    #define GR_IS_GR_WEBGL(standard) false
+    #define SK_DISABLE_GL_ES_INTERFACE 1
+    #define SK_DISABLE_WEBGL_INTERFACE 1
+#elif SK_ASSUME_WEBGL
+    #define GR_IS_GR_GL(standard) false
+    #define GR_IS_GR_GL_ES(standard) false
+    #define GR_IS_GR_WEBGL(standard) true
+    #define SK_DISABLE_GL_ES_INTERFACE 1
+    #define SK_DISABLE_GL_INTERFACE 1
+#else
+    #define GR_IS_GR_GL(standard) (kGL_GrGLStandard == standard)
+    #define GR_IS_GR_GL_ES(standard) (kGLES_GrGLStandard == standard)
+    #define GR_IS_GR_WEBGL(standard) (kWebGL_GrGLStandard == standard)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The supported GL formats represented as an enum. Actual support by GrContext depends on GL
+ * context version and extensions.
+ */
+enum class GrGLFormat {
+    kUnknown,
+
+    kRGBA8,
+    kR8,
+    kALPHA8,
+    kLUMINANCE8,
+    kLUMINANCE8_ALPHA8,
+    kBGRA8,
+    kRGB565,
+    kRGBA16F,
+    kR16F,
+    kRGB8,
+    kRGBX8,
+    kRG8,
+    kRGB10_A2,
+    kRGBA4,
+    kSRGB8_ALPHA8,
+    kCOMPRESSED_ETC1_RGB8,
+    kCOMPRESSED_RGB8_ETC2,
+    kCOMPRESSED_RGB8_BC1,
+    kCOMPRESSED_RGBA8_BC1,
+    kR16,
+    kRG16,
+    kRGBA16,
+    kRG16F,
+    kLUMINANCE16F,
+
+    kLastColorFormat = kLUMINANCE16F,
+
+    // Depth/Stencil formats
+    kSTENCIL_INDEX8,
+    kSTENCIL_INDEX16,
+    kDEPTH24_STENCIL8,
+
+    kLast = kDEPTH24_STENCIL8
+};
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Declares typedefs for all the GL functions used in GrGLInterface
+ */
+
+typedef unsigned int GrGLenum;
+typedef unsigned char GrGLboolean;
+typedef unsigned int GrGLbitfield;
+typedef signed char GrGLbyte;
+typedef char GrGLchar;
+typedef short GrGLshort;
+typedef int GrGLint;
+typedef int GrGLsizei;
+typedef int64_t GrGLint64;
+typedef unsigned char GrGLubyte;
+typedef unsigned short GrGLushort;
+typedef unsigned int GrGLuint;
+typedef uint64_t GrGLuint64;
+typedef unsigned short int GrGLhalf;
+typedef float GrGLfloat;
+typedef float GrGLclampf;
+typedef double GrGLdouble;
+typedef double GrGLclampd;
+typedef void GrGLvoid;
+#ifdef _WIN64
+typedef signed long long int GrGLintptr;
+typedef signed long long int GrGLsizeiptr;
+#else
+typedef signed long int GrGLintptr;
+typedef signed long int GrGLsizeiptr;
+#endif
+typedef void* GrGLeglImage;
+typedef struct __GLsync* GrGLsync;
+
+struct GrGLDrawArraysIndirectCommand {
+    GrGLuint fCount;
+    GrGLuint fInstanceCount;
+    GrGLuint fFirst;
+    GrGLuint fBaseInstance;  // Requires EXT_base_instance on ES.
+};
+
+// static_asserts must have messages in this file because its included in C++14 client code.
+static_assert(16 == sizeof(GrGLDrawArraysIndirectCommand), "");
+
+struct GrGLDrawElementsIndirectCommand {
+    GrGLuint fCount;
+    GrGLuint fInstanceCount;
+    GrGLuint fFirstIndex;
+    GrGLuint fBaseVertex;
+    GrGLuint fBaseInstance;  // Requires EXT_base_instance on ES.
+};
+
+static_assert(20 == sizeof(GrGLDrawElementsIndirectCommand), "");
+
+/**
+ * KHR_debug
+ */
+typedef void (GR_GL_FUNCTION_TYPE* GRGLDEBUGPROC)(GrGLenum source,
+                                                  GrGLenum type,
+                                                  GrGLuint id,
+                                                  GrGLenum severity,
+                                                  GrGLsizei length,
+                                                  const GrGLchar* message,
+                                                  const void* userParam);
+
+/**
+ * EGL types.
+ */
+typedef void* GrEGLImage;
+typedef void* GrEGLDisplay;
+typedef void* GrEGLContext;
+typedef void* GrEGLClientBuffer;
+typedef unsigned int GrEGLenum;
+typedef int32_t GrEGLint;
+typedef unsigned int GrEGLBoolean;
+
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Types for interacting with GL resources created externally to Skia. GrBackendObjects for GL
+ * textures are really const GrGLTexture*. The fFormat here should be a sized, internal format
+ * for the texture. We will try to use the sized format if the GL Context supports it, otherwise
+ * we will internally fall back to using the base internal formats.
+ */
+struct GrGLTextureInfo {
+    GrGLenum fTarget;
+    GrGLuint fID;
+    GrGLenum fFormat = 0;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
+
+    bool operator==(const GrGLTextureInfo& that) const {
+        return fTarget == that.fTarget &&
+               fID == that.fID &&
+               fFormat == that.fFormat &&
+               fProtected == that.fProtected;
+    }
+
+    bool isProtected() const { return fProtected == skgpu::Protected::kYes; }
+};
+
+struct GrGLFramebufferInfo {
+    GrGLuint fFBOID;
+    GrGLenum fFormat = 0;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
+
+    bool operator==(const GrGLFramebufferInfo& that) const {
+        return fFBOID == that.fFBOID &&
+               fFormat == that.fFormat &&
+               fProtected == that.fProtected;
+    }
+
+    bool isProtected() const { return fProtected == skgpu::Protected::kYes; }
+};
+
+struct GrGLSurfaceInfo {
+    uint32_t fSampleCount = 1;
+    uint32_t fLevelCount = 0;
+    skgpu::Protected fProtected = skgpu::Protected::kNo;
+
+    GrGLenum fTarget = 0;
+    GrGLenum fFormat = 0;
+};
+
+#endif

package/cpp/skia/include/gpu/gl/egl/GrGLMakeEGLInterface.h

@@ -0,0 +1,23 @@
+/*
+ * 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 GrGLMakeEGLInterface_DEFINED
+#define GrGLMakeEGLInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrTypes.h"
+
+struct GrGLInterface;
+
+namespace GrGLInterfaces {
+SK_API sk_sp<const GrGLInterface> MakeEGL();
+}
+
+#if !defined(SK_DISABLE_LEGACY_GLXINTERFACE_FACTORY)
+sk_sp<const GrGLInterface> GrGLMakeEGLInterface();
+#endif
+
+#endif  // GrGLMakeEGLInterface_DEFINED

package/cpp/skia/include/gpu/gl/glx/GrGLMakeGLXInterface.h

@@ -0,0 +1,23 @@
+/*
+ * 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 GrGLMakeGLXInterface_DEFINED
+#define GrGLMakeGLXInterface_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+struct GrGLInterface;
+
+namespace GrGLInterfaces {
+SK_API sk_sp<const GrGLInterface> MakeGLX();
+}
+
+#if !defined(SK_DISABLE_LEGACY_GLXINTERFACE_FACTORY)
+sk_sp<const GrGLInterface> GrGLMakeGLXInterface();
+#endif
+
+#endif  // GrGLMakeGLXInterface_DEFINED

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

@@ -0,0 +1,78 @@
+/*
+ * 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_BackendSemaphore_DEFINED
+#define skgpu_graphite_BackendSemaphore_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+
+#ifdef SK_METAL
+#include "include/gpu/graphite/mtl/MtlGraphiteTypes.h"
+#endif
+
+#ifdef SK_VULKAN
+#include "include/private/gpu/vk/SkiaVulkan.h"
+#endif
+
+namespace skgpu::graphite {
+
+class SK_API BackendSemaphore {
+public:
+    BackendSemaphore();
+#ifdef SK_METAL
+    // TODO: Determine creator's responsibility for setting refcnt.
+    BackendSemaphore(CFTypeRef mtlEvent, uint64_t value);
+#endif
+
+#ifdef SK_VULKAN
+    BackendSemaphore(VkSemaphore semaphore);
+#endif
+
+    BackendSemaphore(const BackendSemaphore&);
+
+    ~BackendSemaphore();
+
+    BackendSemaphore& operator=(const BackendSemaphore&);
+
+    bool isValid() const { return fIsValid; }
+    BackendApi backend() const { return fBackend; }
+
+#ifdef SK_METAL
+    CFTypeRef getMtlEvent() const;
+    uint64_t getMtlValue() const;
+#endif
+
+#ifdef SK_VULKAN
+    VkSemaphore getVkSemaphore() const;
+#endif
+
+private:
+    // TODO: For now, implement as a union until we figure out the plan for this and BackendTexture.
+    union {
+#ifdef SK_DAWN
+        // TODO: WebGPU doesn't seem to have the notion of an Event or Semaphore
+#endif
+#ifdef SK_METAL
+        struct {
+            CFTypeRef fMtlEvent;    // Expected to be an id<MTLEvent>
+            uint64_t fMtlValue;
+        };
+#endif
+#ifdef SK_VULKAN
+        VkSemaphore fVkSemaphore;
+#endif
+        void* fEnsureUnionNonEmpty;
+    };
+    bool fIsValid = false;
+    BackendApi fBackend;
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_BackendSemaphore_DEFINED
+

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

@@ -0,0 +1,164 @@
+/*
+ * 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_BackendTexture_DEFINED
+#define skgpu_graphite_BackendTexture_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/TextureInfo.h"
+
+#ifdef SK_DAWN
+#include "include/gpu/graphite/dawn/DawnTypes.h"
+#endif
+
+#ifdef SK_METAL
+#include "include/gpu/graphite/mtl/MtlGraphiteTypes.h"
+#endif
+
+#ifdef SK_VULKAN
+#include "include/gpu/vk/VulkanTypes.h"
+#include "include/private/gpu/vk/SkiaVulkan.h"
+#endif
+
+namespace skgpu {
+class MutableTextureState;
+}
+
+namespace skgpu::graphite {
+
+class SK_API BackendTexture {
+public:
+    BackendTexture();
+#ifdef SK_DAWN
+    // Create a BackendTexture from a WGPUTexture. Texture info will be queried from the texture.
+    //
+    // This is the recommended way of specifying a BackendTexture for Dawn. See the note below on
+    // the constructor that takes a WGPUTextureView for a fuller explanation.
+    //
+    // The BackendTexture will not call retain or release on the passed in WGPUTexture. Thus, the
+    // client must keep the WGPUTexture valid until they are no longer using the BackendTexture.
+    // However, any SkImage or SkSurface that wraps the BackendTexture *will* retain and release
+    // the WGPUTexture.
+    BackendTexture(WGPUTexture texture);
+
+    // Create a BackendTexture from a WGPUTexture. Texture planeDimensions, plane aspect and
+    // info have to be provided. This is intended to be used only when accessing a plane
+    // of a WGPUTexture.
+    //
+    // The BackendTexture will not call retain or release on the passed in WGPUTexture. Thus, the
+    // client must keep the WGPUTexture valid until they are no longer using the BackendTexture.
+    // However, any SkImage or SkSurface that wraps the BackendTexture *will* retain and release
+    // the WGPUTexture.
+    BackendTexture(SkISize planeDimensions, const DawnTextureInfo& info, WGPUTexture texture);
+
+    // Create a BackendTexture from a WGPUTextureView. Texture dimensions and
+    // info have to be provided.
+    //
+    // Using a WGPUTextureView rather than a WGPUTexture is less effecient for operations that
+    // require buffer transfers to or from the texture (e.g. methods on graphite::Context that read
+    // pixels or SkSurface::writePixels). In such cases an intermediate copy to or from a
+    // WGPUTexture is required. Thus, it is recommended to use this functionality only for cases
+    // where a WGPUTexture is unavailable, in particular when using wgpu::SwapChain.
+    //
+    // The BackendTexture will not call retain or release on the passed in WGPUTextureView. Thus,
+    // the client must keep the WGPUTextureView valid until they are no longer using the
+    // BackendTexture. However, any SkImage or SkSurface that wraps the BackendTexture *will* retain
+    // and release the WGPUTextureView.
+    BackendTexture(SkISize dimensions, const DawnTextureInfo& info, WGPUTextureView textureView);
+#endif
+#ifdef SK_METAL
+    // The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
+    // client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
+    BackendTexture(SkISize dimensions, CFTypeRef mtlTexture);
+#endif
+
+#ifdef SK_VULKAN
+    BackendTexture(SkISize dimensions,
+                   const VulkanTextureInfo&,
+                   VkImageLayout,
+                   uint32_t queueFamilyIndex,
+                   VkImage,
+                   VulkanAlloc);
+#endif
+
+    BackendTexture(const BackendTexture&);
+
+    ~BackendTexture();
+
+    BackendTexture& operator=(const BackendTexture&);
+
+    bool operator==(const BackendTexture&) const;
+    bool operator!=(const BackendTexture& that) const { return !(*this == that); }
+
+    bool isValid() const { return fInfo.isValid(); }
+    BackendApi backend() const { return fInfo.backend(); }
+
+    SkISize dimensions() const { return fDimensions; }
+
+    const TextureInfo& info() const { return fInfo; }
+
+    // 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&);
+
+#ifdef SK_DAWN
+    WGPUTexture getDawnTexturePtr() const;
+    WGPUTextureView getDawnTextureViewPtr() const;
+#endif
+#ifdef SK_METAL
+    CFTypeRef getMtlTexture() const;
+#endif
+
+#ifdef SK_VULKAN
+    VkImage getVkImage() const;
+    VkImageLayout getVkImageLayout() const;
+    uint32_t getVkQueueFamilyIndex() const;
+    const VulkanAlloc* getMemoryAlloc() const;
+#endif
+
+private:
+    friend class VulkanResourceProvider;    // for getMutableState
+    sk_sp<MutableTextureState> getMutableState() const;
+
+    SkISize fDimensions;
+    TextureInfo fInfo;
+
+    sk_sp<MutableTextureState> fMutableState;
+
+#ifdef SK_VULKAN
+    // fMemoryAlloc == VulkanAlloc() if the client has already created their own VkImage and
+    // will destroy it themselves as opposed to having Skia create/destroy it via
+    // Recorder::createBackendTexture and Context::deleteBackendTexture.
+    VulkanAlloc fMemoryAlloc = VulkanAlloc();
+#endif
+
+    union {
+#ifdef SK_DAWN
+        struct {
+            WGPUTexture fDawnTexture;
+            WGPUTextureView fDawnTextureView;
+        };
+#endif
+#ifdef SK_METAL
+        CFTypeRef fMtlTexture;
+#endif
+#ifdef SK_VULKAN
+        VkImage fVkImage = VK_NULL_HANDLE;
+#endif
+        void* fEnsureUnionNonEmpty;
+    };
+};
+
+} // namespace skgpu::graphite
+
+#endif // skgpu_graphite_BackendTexture_DEFINED
+