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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/*
* Copyright 2024 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_precompile_PrecompileShader_DEFINED
#define skgpu_graphite_precompile_PrecompileShader_DEFINED
#include "include/gpu/graphite/precompile/PrecompileBase.h"
#include "include/core/SkBlendMode.h"
class SkColorSpace;
namespace skgpu::graphite {
class PrecompileBlender;
class PrecompileColorFilter;
class PrecompileShaderPriv;
/** \class PrecompileShader
This class corresponds to the SkShader class in the main API.
*/
class SK_API PrecompileShader : public PrecompileBase {
public:
/**
* This is the Precompile correlate to SkShader::makeWithLocalMatrix. The actual matrix
* involved is abstracted away, except for whether or the not the matrix involves perspective
* so the correct generated shader variation is chosen.
* The PrecompileShaders::LocalMatrix factory can be used to generate a set of shaders
* that would've been generated via multiple makeWithLocalMatrix calls. That is, rather than
* performing:
* sk_sp<PrecompileShader> option1 = source1->makeWithLocalMatrix(false);
* sk_sp<PrecompileShader> option2 = source2->makeWithLocalMatrix(false);
* one could call:
* sk_sp<PrecompileShader> combinedOptions = LocalMatrix({ source1, source2 }, false);
*/
sk_sp<PrecompileShader> makeWithLocalMatrix(bool isPerspective) const;
/**
* This is the Precompile correlate to SkShader::makeWithColorFilter.
* The PrecompileShaders::ColorFilter factory can be used to generate a set of shaders that
* would've been generated via multiple makeWithColorFilter calls. That is, rather than
* performing:
* sk_sp<PrecompileShader> option1 = source->makeWithColorFilter(colorFilter1);
* sk_sp<PrecompileShader> option2 = source->makeWithColorFilter(colorFilter2);
* one could call:
* sk_sp<PrecompileShader> combinedOptions = ColorFilter({ source },
* { colorFilter1, colorFilter2 });
* With an alternative use case one could also use the ColorFilter factory thusly:
* sk_sp<PrecompileShader> combinedOptions = ColorFilter({ source1, source2 },
* { colorFilter });
*/
sk_sp<PrecompileShader> makeWithColorFilter(sk_sp<PrecompileColorFilter>) const;
/**
* This is the Precompile correlate to SkShader::makeWithWorkingColorSpace.
* The PrecompileShaders::WorkingColorSpace factory can be used to generate a set of shaders
* that would've been generated via multiple makeWithWorkingColorSpace calls. That is, rather
* than performing:
* sk_sp<PrecompileShader> option1 = source->makeWithWorkingColorSpace(colorSpace1);
* sk_sp<PrecompileShader> option2 = source->makeWithWorkingColorSpace(colorSpace2);
* one could call:
* sk_sp<PrecompileShader> combinedOptions = WorkingColorSpace({ source },
* { colorSpace1,
* colorSpace2 });
* With an alternative use case one could also use the WorkingColorSpace factory thusly:
* sk_sp<PrecompileShader> combinedOptions = WorkingColorSpace({ source1, source2 },
* { colorSpace });
*/
sk_sp<PrecompileShader> makeWithWorkingColorSpace(sk_sp<SkColorSpace>) const;
// Provides access to functions that aren't part of the public API.
PrecompileShaderPriv priv();
const PrecompileShaderPriv priv() const; // NOLINT(readability-const-return-type)
protected:
friend class PrecompileShaderPriv;
PrecompileShader() : PrecompileBase(Type::kShader) {}
~PrecompileShader() override;
virtual bool isConstant(int /* desiredCombination */) const { return false; }
virtual bool isALocalMatrixShader() const { return false; }
};
//--------------------------------------------------------------------------------------------------
// This is the Precompile correlate to the SkShaders namespace in the main API
namespace PrecompileShaders {
// --- This block of eight matches the SkShaders factories in SkShader.h
// Note that some of the details of the main API have been elided since they don't impact
// the generated shader (e.g., the color parameter to the Color() factories).
SK_API sk_sp<PrecompileShader> Empty();
SK_API sk_sp<PrecompileShader> Color();
SK_API sk_sp<PrecompileShader> Color(sk_sp<SkColorSpace>);
SK_API sk_sp<PrecompileShader> Blend(SkSpan<const SkBlendMode> blendModes,
SkSpan<const sk_sp<PrecompileShader>> dsts,
SkSpan<const sk_sp<PrecompileShader>> srcs);
SK_API sk_sp<PrecompileShader> Blend(SkSpan<const sk_sp<PrecompileBlender>> blenders,
SkSpan<const sk_sp<PrecompileShader>> dsts,
SkSpan<const sk_sp<PrecompileShader>> srcs);
SK_API sk_sp<PrecompileShader> CoordClamp(SkSpan<const sk_sp<PrecompileShader>>);
// In the main Skia API ImageShaders are usually created via a SkImage::makeShader call.
// Since the SkImage used to create the ImageShader is unlikely to be present at precompilation
// time this entry point allows the equivalent precompilation program structure to be created.
// Note that this factory is for non-YUV SkImages, the YUVImage factory (below) should be used
// to represent the shading and sampling required for YUV images.
SK_API sk_sp<PrecompileShader> Image();
// As with the above Image call, raw ImageShaders are usually created via an
// SkImage::makeRawShader call. The RawImage call allows the equivalent precompilation
// program structure to be created without needing the SkImage.
SK_API sk_sp<PrecompileShader> RawImage();
// In the main Skia API, the specifics of the SkImage used for the SkImage::makeShader call
// can determine whether normal or YUV sampling is required. This entry point allows clients
// to specify that the future image will be a YUV image.
SK_API sk_sp<PrecompileShader> YUVImage();
// --- This block of two matches the SkShaders factories in SkPerlinNoiseShader.h
// Again, most of the details have been elided.
SK_API sk_sp<PrecompileShader> MakeFractalNoise();
SK_API sk_sp<PrecompileShader> MakeTurbulence();
// --- This block of four matches all the factories in SkGradientShader (SkGradientShader.h)
SK_API sk_sp<PrecompileShader> LinearGradient();
SK_API sk_sp<PrecompileShader> RadialGradient();
SK_API sk_sp<PrecompileShader> TwoPointConicalGradient();
SK_API sk_sp<PrecompileShader> SweepGradient();
// Normally, SkPicture shaders are only created via SkPicture::makeShader. Since the
// SkPicture to be drawn, most likely, won't be available at precompilation time, this
// entry point can be used to create a precompilation equivalent.
// Note: this will precompile the program that draws the SkPicture. It, obviously, won't
// precompile any SkPaints within the SkPicture.
SK_API sk_sp<PrecompileShader> Picture();
// Normally, LocalMatrixShaders are only created via SkShader::makeWithLocalMatrix.
// However, in the combination API, clients may want to create a set of precompile
// LocalMatrixShaders (i.e., pass an SkSpan to the factory function vs just creating a
// single option). This entry point allows that use case.
// Note: PrecompileShader::makeWithLocalMatrix() can still be used and works as expected.
SK_API sk_sp<PrecompileShader> LocalMatrix(SkSpan<const sk_sp<PrecompileShader>> wrapped,
bool isPerspective = false);
// Normally, ColorFilterShaders are only created via SkShader::makeWithColorFilter.
// However, in the combination API, clients may want to create a set of precompile
// ColorFilterShaders (i.e., pass SkSpans to the factory function vs just creating a
// single option). This entry point allows that use case.
// Note: PrecompileShader::makeWithColorFilter can still be used and works as expected.
SK_API sk_sp<PrecompileShader> ColorFilter(
SkSpan<const sk_sp<PrecompileShader>> shaders,
SkSpan<const sk_sp<PrecompileColorFilter>> colorFilters);
// Normally, WorkingColorSpaceShaders are only created via SkShader::makeWithWorkingColorSpace.
// However, in the combination API, clients may want to create a set of precompile
// WorkingColorSpaceShaders (i.e., pass SkSpans to the factory function vs just creating a
// single option). This entry point allows that use case.
// Note: PrecompileShader::makeWithWorkingColorSpace can still be used and works as expected.
SK_API sk_sp<PrecompileShader> WorkingColorSpace(SkSpan<const sk_sp<PrecompileShader>> shaders,
SkSpan<const sk_sp<SkColorSpace>> colorSpaces);
} // namespace PrecompileShaders
} // namespace skgpu::graphite
#endif // skgpu_graphite_precompile_PrecompileShader_DEFINED
|
