1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
/*
* 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_Surface_DEFINED
#define skgpu_graphite_Surface_DEFINED
#include "include/core/SkRefCnt.h"
#include "include/core/SkSurface.h"
#include "include/gpu/GpuTypes.h"
#include <string_view>
class SkImage;
struct SkImageInfo;
namespace skgpu::graphite {
class BackendTexture;
class Recorder;
} // namespace skgpu::graphite
namespace SkSurfaces {
using ReleaseContext = void*;
using TextureReleaseProc = void (*)(ReleaseContext);
/**
* The 'AsImage' and 'AsImageCopy' API/entry points are currently only available for
* Graphite.
*
* In this API, SkSurface no longer supports copy-on-write behavior. Instead, when creating
* an image for a surface, the client must explicitly indicate if a copy should be made.
* In both of the below calls the resource backing the surface will never change.
*
* The 'AsImage' entry point has some major ramifications for the mutability of the
* returned SkImage. Since the originating surface and the returned image share the
* same backing, care must be taken by the client to ensure that the contents of the image
* reflect the desired contents when it is consumed by the gpu.
* Note: if the backing GPU buffer isn't textureable this method will return null. Graphite
* will not attempt to make a copy.
* Note: For 'AsImage', the mipmapping of the image will match that of the source surface.
*
* The 'AsImageCopy' entry point allows subsetting and the addition of mipmaps (since
* a copy is already being made).
*
* In Graphite, the legacy API call (i.e., makeImageSnapshot) will just always make a copy.
*/
SK_API sk_sp<SkImage> AsImage(sk_sp<const SkSurface>);
SK_API sk_sp<SkImage> AsImageCopy(sk_sp<const SkSurface>,
const SkIRect* subset = nullptr,
skgpu::Mipmapped = skgpu::Mipmapped::kNo);
/**
* In Graphite, while clients hold a ref on an SkSurface, the backing gpu object does _not_
* count against the budget. Once an SkSurface is freed, the backing gpu object may or may
* not become a scratch (i.e., reusable) resource but, if it does, it will be counted against
* the budget.
*/
SK_API sk_sp<SkSurface> RenderTarget(skgpu::graphite::Recorder*,
const SkImageInfo& imageInfo,
skgpu::Mipmapped = skgpu::Mipmapped::kNo,
const SkSurfaceProps* surfaceProps = nullptr,
std::string_view label = {});
/**
* Wraps a GPU-backed texture in an SkSurface. Depending on the backend gpu API, the caller may
* be required to ensure the texture is valid for the lifetime of the returned SkSurface. The
* required lifetimes for the specific apis are:
* Metal: Skia will call retain on the underlying MTLTexture so the caller can drop it once
* this call returns.
*
* SkSurface is returned if all the parameters are valid. The backendTexture is valid if its
* format agrees with colorSpace and recorder; for instance, if backendTexture has an sRGB
* configuration, then the recorder must support sRGB, and colorSpace must be present. Further,
* backendTexture's width and height must not exceed the recorder's capabilities, and the
* recorder must be able to support the back-end texture.
*/
SK_API sk_sp<SkSurface> WrapBackendTexture(skgpu::graphite::Recorder*,
const skgpu::graphite::BackendTexture&,
SkColorType colorType,
sk_sp<SkColorSpace> colorSpace,
const SkSurfaceProps* props,
TextureReleaseProc = nullptr,
ReleaseContext = nullptr,
std::string_view label = {});
} // namespace SkSurfaces
#endif // skgpu_graphite_Surface_DEFINED
|
