react-native-skia 0.0.1 → 2.15.0

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

@@ -0,0 +1,130 @@
+/*
+ * 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/SkTypes.h"
+#include "include/core/SkYUVAInfo.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/gpu/ganesh/GrTypes.h"
+
+#include <array>
+#include <cstddef>
+
+enum SkYUVColorSpace : int;
+
+/**
+ * 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 skgpu::Mipmapped. 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],
+                             skgpu::Mipmapped,
+                             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(); }
+
+    skgpu::Mipmapped 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];
+    skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::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/ganesh/SkImageGanesh.h

@@ -0,0 +1,361 @@
+/*
+ * 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 SkImageGanesh_DEFINED
+#define SkImageGanesh_DEFINED
+
+#include "include/core/SkImage.h"
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
+#include "include/private/SkAPI.h"
+
+#include <functional>
+#include <utility>
+
+class GrBackendTexture;
+class GrDirectContext;
+class GrRecordingContext;
+class GrYUVABackendTextures;
+class SkColorSpace;
+class SkData;
+class SkImageFilter;
+struct SkIPoint;
+class SkPixmap;
+class SkYUVAPixmaps;
+enum SkAlphaType : int;
+enum SkColorType : int;
+enum class SkTextureCompressionType;
+struct SkIRect;
+
+/**
+ * All factories in this file refer to the Ganesh GPU backend when they say GPU.
+ */
+
+namespace SkImages {
+/** Defines a callback function, taking one parameter of type GrBackendTexture with
+    no return value. Function is called when backend texture is to be released.
+*/
+using BackendTextureReleaseProc = std::function<void(GrBackendTexture)>;
+/** User function called when supplied texture may be deleted. */
+using TextureReleaseProc = void (*)(ReleaseContext);
+
+/** Creates GPU-backed SkImage from backendTexture associated with context.
+    Skia will assume ownership of the resource and will release it when no longer needed.
+    A non-null SkImage is returned if format of backendTexture is recognized and supported.
+    Recognized formats vary by GPU backend.
+    @param context         GPU context
+    @param backendTexture  texture residing on GPU
+    @param textureOrigin   origin of backendTexture
+    @param colorType       color type of the resulting image
+    @param alphaType       alpha type of the resulting image
+    @param colorSpace      range of colors; may be nullptr
+    @return                created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> AdoptTextureFrom(GrRecordingContext* context,
+                                       const GrBackendTexture& backendTexture,
+                                       GrSurfaceOrigin textureOrigin,
+                                       SkColorType colorType);
+SK_API sk_sp<SkImage> AdoptTextureFrom(GrRecordingContext* context,
+                                       const GrBackendTexture& backendTexture,
+                                       GrSurfaceOrigin textureOrigin,
+                                       SkColorType colorType,
+                                       SkAlphaType alphaType);
+SK_API sk_sp<SkImage> AdoptTextureFrom(GrRecordingContext* context,
+                                       const GrBackendTexture& backendTexture,
+                                       GrSurfaceOrigin textureOrigin,
+                                       SkColorType colorType,
+                                       SkAlphaType alphaType,
+                                       sk_sp<SkColorSpace> colorSpace);
+
+/** Creates GPU-backed SkImage from the provided GPU texture associated with context.
+    GPU texture must stay valid and unchanged until textureReleaseProc is called by Skia.
+    Skia will call textureReleaseProc with the passed-in releaseContext when SkImage
+    is deleted or no longer refers to the texture.
+    A non-null SkImage is returned if format of backendTexture is recognized and supported.
+    Recognized formats vary by GPU backend.
+    @note When using a DDL recording context, textureReleaseProc will be called on the
+    GPU thread after the DDL is played back on the direct context.
+    @param context             GPU context
+    @param backendTexture      texture residing on GPU
+    @param colorSpace          This describes the color space of this image's contents, as
+                               seen after sampling. In general, if the format of the backend
+                               texture is SRGB, some linear colorSpace should be supplied
+                               (e.g., SkColorSpace::MakeSRGBLinear()). If the format of the
+                               backend texture is linear, then the colorSpace should include
+                               a description of the transfer function as
+                               well (e.g., SkColorSpace::MakeSRGB()).
+    @param textureReleaseProc  function called when texture can be released
+    @param releaseContext      state passed to textureReleaseProc
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> BorrowTextureFrom(GrRecordingContext* context,
+                                        const GrBackendTexture& backendTexture,
+                                        GrSurfaceOrigin origin,
+                                        SkColorType colorType,
+                                        SkAlphaType alphaType,
+                                        sk_sp<SkColorSpace> colorSpace,
+                                        TextureReleaseProc textureReleaseProc = nullptr,
+                                        ReleaseContext releaseContext = nullptr);
+
+/** Creates a GPU-backed SkImage from pixmap. It is uploaded to GPU backend using context.
+    Created SkImage is available to other GPU contexts, and is available across thread
+    boundaries. All contexts must be in the same GPU share group, or otherwise
+    share resources.
+    When SkImage is no longer referenced, context releases texture memory
+    asynchronously.
+    SkColorSpace of SkImage is determined by pixmap.colorSpace().
+    SkImage is returned referring to GPU backend if context is not nullptr,
+    format of data is recognized and supported, and if context supports moving
+    resources between contexts. Otherwise, pixmap pixel data is copied and SkImage
+    as returned in raster format if possible; nullptr may be returned.
+    Recognized GPU formats vary by platform and GPU backend.
+    @param context                GPU context
+    @param pixmap                 SkImageInfo, pixel address, and row bytes
+    @param buildMips              create SkImage as mip map if true
+    @param limitToMaxTextureSize  downscale image to GPU maximum texture size, if necessary
+    @return                       created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> CrossContextTextureFromPixmap(GrDirectContext* context,
+                                                    const SkPixmap& pixmap,
+                                                    bool buildMips,
+                                                    bool limitToMaxTextureSize = false);
+
+/** Creates a GPU-backed SkImage from a GPU backend texture. The backend texture must stay
+    valid and unchanged until textureReleaseProc is called. The textureReleaseProc is
+    called when the SkImage is deleted or no longer refers to the texture and will be
+    passed the releaseContext.
+    An SkImage is returned if the format of backendTexture is recognized and supported.
+    Recognized formats vary by GPU backend.
+    @note When using a DDL recording context, textureReleaseProc will be called on the
+    GPU thread after the DDL is played back on the direct context.
+    @param context             the GPU context
+    @param backendTexture      a texture already allocated by the GPU
+    @param alphaType           This characterizes the nature of the alpha values in the
+                               backend texture. For opaque compressed formats (e.g., ETC1)
+                               this should usually be set to kOpaq
+                               ue_SkAlphaType.
+    @param colorSpace          This describes the color space of this image's contents, as
+                               seen after sampling. In general, if the format of the backend
+                               texture is SRGB, some linear colorSpace should be supplied
+                               (e.g., SkColorSpace::MakeSRGBLinear()). If the format of the
+                               backend texture is linear, then the colorSpace should include
+                               a description of the transfer function as
+                               well (e.g., SkColorSpace::MakeSRGB()).
+    @param textureReleaseProc  function called when the backend texture can be released
+    @param releaseContext      state passed to textureReleaseProc
+    @return                    created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromCompressedTexture(GrRecordingContext* context,
+                                                   const GrBackendTexture& backendTexture,
+                                                   GrSurfaceOrigin origin,
+                                                   SkAlphaType alphaType,
+                                                   sk_sp<SkColorSpace> colorSpace,
+                                                   TextureReleaseProc textureReleaseProc = nullptr,
+                                                   ReleaseContext releaseContext = nullptr);
+
+/** Creates a GPU-backed SkImage from compressed data.
+    This method will return an SkImage representing the compressed data.
+    If the GPU doesn't support the specified compression method, the data
+    will be decompressed and then wrapped in a GPU-backed image.
+    Note: one can query the supported compression formats via
+    GrRecordingContext::compressedBackendFormat.
+    @param context     GPU context
+    @param data        compressed data to store in SkImage
+    @param width       width of full SkImage
+    @param height      height of full SkImage
+    @param type        type of compression used
+    @param mipmapped   does 'data' contain data for all the mipmap levels?
+    @param isProtected do the contents of 'data' require DRM protection (on Vulkan)?
+    @return            created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromCompressedTextureData(
+        GrDirectContext* direct,
+        sk_sp<SkData> data,
+        int width,
+        int height,
+        SkTextureCompressionType type,
+        skgpu::Mipmapped mipmapped = skgpu::Mipmapped::kNo,
+        GrProtected isProtected = GrProtected::kNo);
+
+/** Returns SkImage backed by GPU texture associated with context. Returned SkImage is
+    compatible with SkSurface created with dstColorSpace. The returned SkImage respects
+    mipmapped setting; if mipmapped equals skgpu::Mipmapped::kYes, the backing texture
+    allocates mip map levels.
+    The mipmapped parameter is effectively treated as kNo if MIP maps are not supported by the
+    GPU.
+    Returns original SkImage if the image is already texture-backed, the context matches, and
+    mipmapped is compatible with the backing GPU texture. skgpu::Budgeted is ignored in this
+   case.
+    Returns nullptr if context is nullptr, or if SkImage was created with another
+    GrDirectContext.
+    @param GrDirectContext  the GrDirectContext in play, if it exists
+    @param SkImage          a non-null pointer to an SkImage.
+    @param skgpu::Mipmapped Whether created SkImage texture must allocate mip map levels.
+                            Defaults to no.
+    @param skgpu::Budgeted  Whether to count a newly created texture for the returned image
+                            counts against the context's budget. Defaults to yes.
+    @return                 created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromImage(GrDirectContext*,
+                                       const SkImage*,
+                                       skgpu::Mipmapped = skgpu::Mipmapped::kNo,
+                                       skgpu::Budgeted = skgpu::Budgeted::kYes);
+inline sk_sp<SkImage> TextureFromImage(GrDirectContext* ctx,
+                                       const sk_sp<const SkImage>& img,
+                                       skgpu::Mipmapped m = skgpu::Mipmapped::kNo,
+                                       skgpu::Budgeted b = skgpu::Budgeted::kYes) {
+    return TextureFromImage(ctx, img.get(), m, b);
+}
+
+/** Creates a GPU-backed SkImage from SkYUVAPixmaps.
+    The image will remain planar with each plane converted to a texture using the passed
+    GrRecordingContext.
+    SkYUVAPixmaps has a SkYUVAInfo which specifies the transformation from YUV to RGB.
+    The SkColorSpace of the resulting RGB values is specified by imageColorSpace. This will
+    be the SkColorSpace reported by the image and when drawn the RGB values will be converted
+    from this space into the destination space (if the destination is tagged).
+    Currently, this is only supported using the GPU backend and will fail if context is nullptr.
+    SkYUVAPixmaps does not need to remain valid after this returns.
+    @param context                GPU context
+    @param pixmaps                The planes as pixmaps with supported SkYUVAInfo that
+                                  specifies conversion to RGB.
+    @param buildMips              create internal YUVA textures as mip map if kYes. This is
+                                  silently ignored if the context does not support mip maps.
+    @param limitToMaxTextureSize  downscale image to GPU maximum texture size, if necessary
+    @param imageColorSpace        range of colors of the resulting image; may be nullptr
+    @return                       created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromYUVAPixmaps(GrRecordingContext* context,
+                                             const SkYUVAPixmaps& pixmaps,
+                                             skgpu::Mipmapped buildMips,
+                                             bool limitToMaxTextureSize,
+                                             sk_sp<SkColorSpace> imageColorSpace);
+SK_API sk_sp<SkImage> TextureFromYUVAPixmaps(GrRecordingContext* context,
+                                             const SkYUVAPixmaps& pixmaps,
+                                             skgpu::Mipmapped buildMips = skgpu::Mipmapped::kNo,
+                                             bool limitToMaxTextureSize = false);
+
+/** Creates a GPU-backed SkImage from YUV[A] planar textures. This requires that the textures
+ *  stay valid for the lifetime of the image. The ReleaseContext can be used to know when it is
+ *  safe to either delete or overwrite the textures. If ReleaseProc is provided it is also called
+ *  before return on failure.
+    @param context            GPU context
+    @param yuvaTextures       A set of textures containing YUVA data and a description of the
+                              data and transformation to RGBA.
+    @param imageColorSpace    range of colors of the resulting image after conversion to RGB;
+                              may be nullptr
+    @param textureReleaseProc called when the backend textures can be released
+    @param releaseContext     state passed to textureReleaseProc
+    @return                   created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromYUVATextures(GrRecordingContext* context,
+                                              const GrYUVABackendTextures& yuvaTextures,
+                                              sk_sp<SkColorSpace> imageColorSpace,
+                                              TextureReleaseProc textureReleaseProc = nullptr,
+                                              ReleaseContext releaseContext = nullptr);
+SK_API sk_sp<SkImage> TextureFromYUVATextures(GrRecordingContext* context,
+                                              const GrYUVABackendTextures& yuvaTextures);
+
+/** Retrieves the existing backend texture. If SkImage is not a Ganesh-backend texture image
+    or otherwise does not have such a texture, false is returned. Otherwise, outTexture will
+    be set to the image's texture.
+
+    If flushPendingGrContextIO is true, completes deferred I/O operations.
+    If origin in not nullptr, copies location of content drawn into SkImage.
+    @param outTexture               Will be set to the underlying texture of the image if non-null.
+    @param flushPendingGrContextIO  flag to flush outstanding requests
+    @param origin                   Will be set to the origin orientation of the image if non-null.
+    @return                         false if a Ganesh backend texture cannot be retrieved.
+*/
+SK_API bool GetBackendTextureFromImage(const SkImage* img,
+                                       GrBackendTexture* outTexture,
+                                       bool flushPendingGrContextIO,
+                                       GrSurfaceOrigin* origin = nullptr);
+inline bool GetBackendTextureFromImage(const sk_sp<const SkImage>& img,
+                                       GrBackendTexture* outTexture,
+                                       bool flushPendingGrContextIO,
+                                       GrSurfaceOrigin* origin = nullptr) {
+    return GetBackendTextureFromImage(img.get(), outTexture, flushPendingGrContextIO, origin);
+}
+
+/** Extracts the backendTexture from an existing SkImage.
+    If the image is not already GPU-backed, the raster data will be uploaded as a texture
+    and returned.
+    If this is the only reference to the image, the old image's texture will be
+    moved out of the passed in image.
+    If the image is shared (has a refcount > 1), the texture will be copied and then returned.
+    @param context                    GPU context
+    @param image                      image, either CPU-backed or GPU-backed
+    @param backendTexture             Will be set to the underlying texture of the image.
+    @param backendTextureReleaseProc  Called when the texture is released
+    @return                           false if image cannot be uploaded.
+*/
+SK_API bool MakeBackendTextureFromImage(GrDirectContext* context,
+                                        sk_sp<SkImage> image,
+                                        GrBackendTexture* backendTexture,
+                                        BackendTextureReleaseProc* backendTextureReleaseProc);
+// Legacy name
+inline bool GetBackendTextureFromImage(GrDirectContext* context,
+                                       sk_sp<SkImage> image,
+                                       GrBackendTexture* backendTexture,
+                                       BackendTextureReleaseProc* backendTextureReleaseProc) {
+    return MakeBackendTextureFromImage(context, std::move(image), backendTexture,
+                                       backendTextureReleaseProc);
+}
+
+/** Returns subset of this image as a texture-backed image.
+
+    Returns nullptr if any of the following are true:
+      - Subset is empty
+      - Subset is not contained inside the image's bounds
+      - Pixels in the source image could not be read or copied
+      - The source image is texture-backed and context does not match the source image's context.
+
+    @param context the non-null GrDirectContext to which the subset should be uploaded.
+    @param subset  bounds of returned SkImage
+    @return        the subsetted image, uploaded as a texture, or nullptr
+*/
+SK_API sk_sp<SkImage> SubsetTextureFrom(GrDirectContext* context,
+                                        const SkImage* img,
+                                        const SkIRect& subset);
+
+/** Creates a filtered SkImage on the GPU. filter processes the src image, potentially changing
+    color, position, and size. subset is the bounds of src that are processed
+    by filter. clipBounds is the expected bounds of the filtered SkImage. outSubset
+    is required storage for the actual bounds of the filtered SkImage. offset is
+    required storage for translation of returned SkImage.
+
+    Returns nullptr if SkImage could not be created or if the recording context provided doesn't
+    match the GPU context in which the image was created. If nullptr is returned, outSubset
+    and offset are undefined.
+
+    Useful for animation of SkImageFilter that varies size from frame to frame.
+    Returned SkImage is created larger than required by filter so that GPU texture
+    can be reused with different sized effects. outSubset describes the valid bounds
+    of GPU texture returned. offset translates the returned SkImage to keep subsequent
+    animation frames aligned with respect to each other.
+
+    @param context     the GrRecordingContext in play - if it exists
+    @param filter      how SkImage is sampled when transformed
+    @param subset      bounds of SkImage processed by filter
+    @param clipBounds  expected bounds of filtered SkImage
+    @param outSubset   storage for returned SkImage bounds
+    @param offset      storage for returned SkImage translation
+    @return            filtered SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> MakeWithFilter(GrRecordingContext* context,
+                                     sk_sp<SkImage> src,
+                                     const SkImageFilter* filter,
+                                     const SkIRect& subset,
+                                     const SkIRect& clipBounds,
+                                     SkIRect* outSubset,
+                                     SkIPoint* offset);
+
+}  // namespace SkImages
+
+#endif

package/cpp/skia/include/gpu/ganesh/SkMeshGanesh.h

@@ -0,0 +1,57 @@
+/*
+ * 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 SkMeshGanesh_DEFINED
+#define SkMeshGanesh_DEFINED
+
+#include "include/core/SkMesh.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+#include <cstddef>
+
+class GrDirectContext;
+
+namespace SkMeshes {
+/**
+ * Makes a GPU-backed index buffer to be used with SkMeshes.
+ *
+ * @param  GrDirectContext*  If non-null, the data will be uploaded to the corresponding GPU and the
+ *                           returned buffer will only be compatible with surfaces using the same
+ *                           context. If null, the data will be uploaded to a CPU buffer.
+ * @param  data              The data used to populate the buffer, or nullptr to create a zero-
+ *                           initialized buffer.
+ * @param  size              Both the size of the data in 'data' and the size of the resulting
+ *                           buffer.
+ */
+SK_API sk_sp<SkMesh::IndexBuffer> MakeIndexBuffer(GrDirectContext*, const void* data, size_t size);
+
+/**
+ * Makes a copy of an index buffer. The copy will be GPU backed if the context is non-null.
+ */
+SK_API sk_sp<SkMesh::IndexBuffer> CopyIndexBuffer(GrDirectContext*, sk_sp<SkMesh::IndexBuffer>);
+
+/**
+ * Makes a GPU-backed vertex buffer to be used with SkMeshes.
+ *
+ * @param  GrDirectContext*  If non-null, the data will be uploaded to the corresponding GPU and the
+ *                           returned buffer will only be compatible with surfaces using the same
+ *                           context. If null, the data will be uploaded to a CPU buffer.
+ * @param  data              The data used to populate the buffer, or nullptr to create a zero-
+ *                           initialized buffer.
+ * @param  size              Both the size of the data in 'data' and the size of the resulting
+ *                           buffer.
+ */
+SK_API sk_sp<SkMesh::VertexBuffer> MakeVertexBuffer(GrDirectContext*, const void*, size_t size);
+
+/**
+ * Makes a copy of a vertex buffer. The copy will be GPU backed if the context is non-null.
+ */
+SK_API sk_sp<SkMesh::VertexBuffer> CopyVertexBuffer(GrDirectContext*, sk_sp<SkMesh::VertexBuffer>);
+}  // namespace SkMeshes
+
+#endif