1/*
2 * Copyright 2016 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef SKSL_CONTEXT
9#define SKSL_CONTEXT
10
11#include <memory>
12
13#include "src/sksl/ir/SkSLExpression.h"
14#include "src/sksl/ir/SkSLType.h"
15
16namespace SkSL {
17
18/**
19 * Contains compiler-wide objects, which currently means the core types.
20 */
21class Context {
22public:
23 Context()
24 : fInvalid_Type(new Type("<INVALID>"))
25 , fVoid_Type(new Type("void"))
26 , fNull_Type(new Type("null"))
27 , fFloatLiteral_Type(new Type("$floatLiteral", Type::kFloat_NumberKind, 3))
28 , fIntLiteral_Type(new Type("$intLiteral", Type::kSigned_NumberKind, 1))
29 , fFloat_Type(new Type("float", Type::kFloat_NumberKind, 5, true))
30 , fFloat2_Type(new Type("float2", *fFloat_Type, 2))
31 , fFloat3_Type(new Type("float3", *fFloat_Type, 3))
32 , fFloat4_Type(new Type("float4", *fFloat_Type, 4))
33 , fHalf_Type(new Type("half", Type::kFloat_NumberKind, 4))
34 , fHalf2_Type(new Type("half2", *fHalf_Type, 2))
35 , fHalf3_Type(new Type("half3", *fHalf_Type, 3))
36 , fHalf4_Type(new Type("half4", *fHalf_Type, 4))
37 , fUInt_Type(new Type("uint", Type::kUnsigned_NumberKind, 2, true))
38 , fUInt2_Type(new Type("uint2", *fUInt_Type, 2))
39 , fUInt3_Type(new Type("uint3", *fUInt_Type, 3))
40 , fUInt4_Type(new Type("uint4", *fUInt_Type, 4))
41 , fInt_Type(new Type("int", Type::kSigned_NumberKind, 2, true))
42 , fInt2_Type(new Type("int2", *fInt_Type, 2))
43 , fInt3_Type(new Type("int3", *fInt_Type, 3))
44 , fInt4_Type(new Type("int4", *fInt_Type, 4))
45 , fUShort_Type(new Type("ushort", Type::kUnsigned_NumberKind, 0))
46 , fUShort2_Type(new Type("ushort2", *fUShort_Type, 2))
47 , fUShort3_Type(new Type("ushort3", *fUShort_Type, 3))
48 , fUShort4_Type(new Type("ushort4", *fUShort_Type, 4))
49 , fShort_Type(new Type("short", Type::kSigned_NumberKind, 0))
50 , fShort2_Type(new Type("short2", *fShort_Type, 2))
51 , fShort3_Type(new Type("short3", *fShort_Type, 3))
52 , fShort4_Type(new Type("short4", *fShort_Type, 4))
53 , fUByte_Type(new Type("ubyte", Type::kUnsigned_NumberKind, 0))
54 , fUByte2_Type(new Type("ubyte2", *fUByte_Type, 2))
55 , fUByte3_Type(new Type("ubyte3", *fUByte_Type, 3))
56 , fUByte4_Type(new Type("ubyte4", *fUByte_Type, 4))
57 , fByte_Type(new Type("byte", Type::kSigned_NumberKind, 0))
58 , fByte2_Type(new Type("byte2", *fByte_Type, 2))
59 , fByte3_Type(new Type("byte3", *fByte_Type, 3))
60 , fByte4_Type(new Type("byte4", *fByte_Type, 4))
61 , fBool_Type(new Type("bool", Type::kNonnumeric_NumberKind, -1))
62 , fBool2_Type(new Type("bool2", *fBool_Type, 2))
63 , fBool3_Type(new Type("bool3", *fBool_Type, 3))
64 , fBool4_Type(new Type("bool4", *fBool_Type, 4))
65 , fFloat2x2_Type(new Type("float2x2", *fFloat_Type, 2, 2))
66 , fFloat2x3_Type(new Type("float2x3", *fFloat_Type, 2, 3))
67 , fFloat2x4_Type(new Type("float2x4", *fFloat_Type, 2, 4))
68 , fFloat3x2_Type(new Type("float3x2", *fFloat_Type, 3, 2))
69 , fFloat3x3_Type(new Type("float3x3", *fFloat_Type, 3, 3))
70 , fFloat3x4_Type(new Type("float3x4", *fFloat_Type, 3, 4))
71 , fFloat4x2_Type(new Type("float4x2", *fFloat_Type, 4, 2))
72 , fFloat4x3_Type(new Type("float4x3", *fFloat_Type, 4, 3))
73 , fFloat4x4_Type(new Type("float4x4", *fFloat_Type, 4, 4))
74 , fHalf2x2_Type(new Type("half2x2", *fHalf_Type, 2, 2))
75 , fHalf2x3_Type(new Type("half2x3", *fHalf_Type, 2, 3))
76 , fHalf2x4_Type(new Type("half2x4", *fHalf_Type, 2, 4))
77 , fHalf3x2_Type(new Type("half3x2", *fHalf_Type, 3, 2))
78 , fHalf3x3_Type(new Type("half3x3", *fHalf_Type, 3, 3))
79 , fHalf3x4_Type(new Type("half3x4", *fHalf_Type, 3, 4))
80 , fHalf4x2_Type(new Type("half4x2", *fHalf_Type, 4, 2))
81 , fHalf4x3_Type(new Type("half4x3", *fHalf_Type, 4, 3))
82 , fHalf4x4_Type(new Type("half4x4", *fHalf_Type, 4, 4))
83 , fTexture1D_Type(new Type("texture1D", SpvDim1D, false, false, false, true))
84 , fTexture2D_Type(new Type("texture2D", SpvDim2D, false, false, false, true))
85 , fTexture3D_Type(new Type("texture3D", SpvDim3D, false, false, false, true))
86 , fTextureExternalOES_Type(new Type("textureExternalOES", SpvDim2D, false, false, false, true))
87 , fTextureCube_Type(new Type("textureCube", SpvDimCube, false, false, false, true))
88 , fTexture2DRect_Type(new Type("texture2DRect", SpvDimRect, false, false, false, true))
89 , fTextureBuffer_Type(new Type("textureBuffer", SpvDimBuffer, false, false, false, true))
90 , fITexture2D_Type(new Type("itexture2D", SpvDim2D, false, false, false, true))
91 , fSampler1D_Type(new Type("sampler1D", *fTexture1D_Type))
92 , fSampler2D_Type(new Type("sampler2D", *fTexture2D_Type))
93 , fSampler3D_Type(new Type("sampler3D", *fTexture3D_Type))
94 , fSamplerExternalOES_Type(new Type("samplerExternalOES", *fTextureExternalOES_Type))
95 , fSamplerCube_Type(new Type("samplerCube", *fTextureCube_Type))
96 , fSampler2DRect_Type(new Type("sampler2DRect", *fTexture2DRect_Type))
97 , fSampler1DArray_Type(new Type("sampler1DArray"))
98 , fSampler2DArray_Type(new Type("sampler2DArray"))
99 , fSamplerCubeArray_Type(new Type("samplerCubeArray"))
100 , fSamplerBuffer_Type(new Type("samplerBuffer", *fTextureBuffer_Type))
101 , fSampler2DMS_Type(new Type("sampler2DMS"))
102 , fSampler2DMSArray_Type(new Type("sampler2DMSArray"))
103 , fSampler1DShadow_Type(new Type("sampler1DShadow"))
104 , fSampler2DShadow_Type(new Type("sampler2DShadow"))
105 , fSamplerCubeShadow_Type(new Type("samplerCubeShadow"))
106 , fSampler2DRectShadow_Type(new Type("sampler2DRectShadow"))
107 , fSampler1DArrayShadow_Type(new Type("sampler1DArrayShadow"))
108 , fSampler2DArrayShadow_Type(new Type("sampler2DArrayShadow"))
109 , fSamplerCubeArrayShadow_Type(new Type("samplerCubeArrayShadow"))
110
111 // Related to below FIXME, gsampler*s don't currently expand to cover integer case.
112 , fISampler2D_Type(new Type("isampler2D", *fITexture2D_Type))
113
114 , fSampler_Type(new Type("sampler", Type::kSeparateSampler_Kind))
115 // FIXME express these as "gimage2D" that expand to image2D, iimage2D, and uimage2D.
116 , fImage2D_Type(new Type("image2D", SpvDim2D, false, false, false, true))
117 , fIImage2D_Type(new Type("iimage2D", SpvDim2D, false, false, false, true))
118
119 // FIXME express these as "gsubpassInput" that expand to subpassInput, isubpassInput,
120 // and usubpassInput.
121 , fSubpassInput_Type(new Type("subpassInput", SpvDimSubpassData, false, false,
122 false, false))
123 , fSubpassInputMS_Type(new Type("subpassInputMS", SpvDimSubpassData, false, false,
124 true, false))
125
126 // FIXME figure out what we're supposed to do with the gsampler et al. types)
127 , fGSampler1D_Type(new Type("$gsampler1D", static_type(*fSampler1D_Type)))
128 , fGSampler2D_Type(new Type("$gsampler2D", static_type(*fSampler2D_Type)))
129 , fGSampler3D_Type(new Type("$gsampler3D", static_type(*fSampler3D_Type)))
130 , fGSamplerCube_Type(new Type("$gsamplerCube", static_type(*fSamplerCube_Type)))
131 , fGSampler2DRect_Type(new Type("$gsampler2DRect", static_type(*fSampler2DRect_Type)))
132 , fGSampler1DArray_Type(new Type("$gsampler1DArray",
133 static_type(*fSampler1DArray_Type)))
134 , fGSampler2DArray_Type(new Type("$gsampler2DArray",
135 static_type(*fSampler2DArray_Type)))
136 , fGSamplerCubeArray_Type(new Type("$gsamplerCubeArray",
137 static_type(*fSamplerCubeArray_Type)))
138 , fGSamplerBuffer_Type(new Type("$gsamplerBuffer", static_type(*fSamplerBuffer_Type)))
139 , fGSampler2DMS_Type(new Type("$gsampler2DMS", static_type(*fSampler2DMS_Type)))
140 , fGSampler2DMSArray_Type(new Type("$gsampler2DMSArray",
141 static_type(*fSampler2DMSArray_Type)))
142 , fGSampler2DArrayShadow_Type(new Type("$gsampler2DArrayShadow",
143 static_type(*fSampler2DArrayShadow_Type)))
144 , fGSamplerCubeArrayShadow_Type(new Type("$gsamplerCubeArrayShadow",
145 static_type(*fSamplerCubeArrayShadow_Type)))
146 , fGenType_Type(new Type("$genType", { fFloat_Type.get(), fFloat2_Type.get(),
147 fFloat3_Type.get(), fFloat4_Type.get() }))
148 , fGenHType_Type(new Type("$genHType", { fHalf_Type.get(), fHalf2_Type.get(),
149 fHalf3_Type.get(), fHalf4_Type.get() }))
150 , fGenIType_Type(new Type("$genIType", { fInt_Type.get(), fInt2_Type.get(),
151 fInt3_Type.get(), fInt4_Type.get() }))
152 , fGenUType_Type(new Type("$genUType", { fUInt_Type.get(), fUInt2_Type.get(),
153 fUInt3_Type.get(), fUInt4_Type.get() }))
154 , fGenBType_Type(new Type("$genBType", { fBool_Type.get(), fBool2_Type.get(),
155 fBool3_Type.get(), fBool4_Type.get() }))
156 , fMat_Type(new Type("$mat", { fFloat2x2_Type.get(), fFloat2x3_Type.get(),
157 fFloat2x4_Type.get(), fFloat3x2_Type.get(),
158 fFloat3x3_Type.get(), fFloat3x4_Type.get(),
159 fFloat4x2_Type.get(), fFloat4x3_Type.get(),
160 fFloat4x4_Type.get(), fHalf2x2_Type.get(),
161 fHalf2x3_Type.get(), fHalf2x4_Type.get(),
162 fHalf3x2_Type.get(), fHalf3x3_Type.get(),
163 fHalf3x4_Type.get(), fHalf4x2_Type.get(),
164 fHalf4x3_Type.get(), fHalf4x4_Type.get(),
165 fDouble2x2_Type.get(), fDouble2x3_Type.get(),
166 fDouble2x4_Type.get(), fDouble3x2_Type.get(),
167 fDouble3x3_Type.get(), fDouble3x4_Type.get(),
168 fDouble4x2_Type.get(), fDouble4x3_Type.get(),
169 fDouble4x4_Type.get() }))
170 , fVec_Type(new Type("$vec", { fInvalid_Type.get(), fFloat2_Type.get(),
171 fFloat3_Type.get(), fFloat4_Type.get() }))
172 , fGVec_Type(new Type("$gvec"))
173 , fGVec2_Type(new Type("$gfloat2"))
174 , fGVec3_Type(new Type("$gfloat3"))
175 , fGVec4_Type(new Type("$gfloat4", static_type(*fFloat4_Type)))
176 , fHVec_Type(new Type("$hvec", { fInvalid_Type.get(), fHalf2_Type.get(),
177 fHalf3_Type.get(), fHalf4_Type.get() }))
178 , fIVec_Type(new Type("$ivec", { fInvalid_Type.get(), fInt2_Type.get(),
179 fInt3_Type.get(), fInt4_Type.get() }))
180 , fUVec_Type(new Type("$uvec", { fInvalid_Type.get(), fUInt2_Type.get(),
181 fUInt3_Type.get(), fUInt4_Type.get() }))
182 , fSVec_Type(new Type("$svec", { fInvalid_Type.get(), fShort2_Type.get(),
183 fShort3_Type.get(), fShort4_Type.get() }))
184 , fUSVec_Type(new Type("$usvec", { fInvalid_Type.get(), fUShort2_Type.get(),
185 fUShort3_Type.get(), fUShort4_Type.get() }))
186 , fByteVec_Type(new Type("$bytevec", { fInvalid_Type.get(), fByte2_Type.get(),
187 fByte3_Type.get(), fByte4_Type.get() }))
188 , fUByteVec_Type(new Type("$ubytevec", { fInvalid_Type.get(), fUByte2_Type.get(),
189 fUByte3_Type.get(), fUByte4_Type.get() }))
190 , fBVec_Type(new Type("$bvec", { fInvalid_Type.get(), fBool2_Type.get(),
191 fBool3_Type.get(), fBool4_Type.get() }))
192 , fSkCaps_Type(new Type("$sk_Caps"))
193 , fFragmentProcessor_Type(fp_type(fInt_Type.get(), fBool_Type.get()))
194 , fDefined_Expression(new Defined(*fInvalid_Type)) {}
195
196 static std::vector<const Type*> static_type(const Type& t) {
197 return { &t, &t, &t, &t };
198 }
199
200 const std::unique_ptr<Type> fInvalid_Type;
201 const std::unique_ptr<Type> fVoid_Type;
202 const std::unique_ptr<Type> fNull_Type;
203 const std::unique_ptr<Type> fFloatLiteral_Type;
204 const std::unique_ptr<Type> fIntLiteral_Type;
205
206 const std::unique_ptr<Type> fFloat_Type;
207 const std::unique_ptr<Type> fFloat2_Type;
208 const std::unique_ptr<Type> fFloat3_Type;
209 const std::unique_ptr<Type> fFloat4_Type;
210
211 const std::unique_ptr<Type> fHalf_Type;
212 const std::unique_ptr<Type> fHalf2_Type;
213 const std::unique_ptr<Type> fHalf3_Type;
214 const std::unique_ptr<Type> fHalf4_Type;
215
216 const std::unique_ptr<Type> fUInt_Type;
217 const std::unique_ptr<Type> fUInt2_Type;
218 const std::unique_ptr<Type> fUInt3_Type;
219 const std::unique_ptr<Type> fUInt4_Type;
220
221 const std::unique_ptr<Type> fInt_Type;
222 const std::unique_ptr<Type> fInt2_Type;
223 const std::unique_ptr<Type> fInt3_Type;
224 const std::unique_ptr<Type> fInt4_Type;
225
226 const std::unique_ptr<Type> fUShort_Type;
227 const std::unique_ptr<Type> fUShort2_Type;
228 const std::unique_ptr<Type> fUShort3_Type;
229 const std::unique_ptr<Type> fUShort4_Type;
230
231 const std::unique_ptr<Type> fShort_Type;
232 const std::unique_ptr<Type> fShort2_Type;
233 const std::unique_ptr<Type> fShort3_Type;
234 const std::unique_ptr<Type> fShort4_Type;
235
236 const std::unique_ptr<Type> fUByte_Type;
237 const std::unique_ptr<Type> fUByte2_Type;
238 const std::unique_ptr<Type> fUByte3_Type;
239 const std::unique_ptr<Type> fUByte4_Type;
240
241 const std::unique_ptr<Type> fByte_Type;
242 const std::unique_ptr<Type> fByte2_Type;
243 const std::unique_ptr<Type> fByte3_Type;
244 const std::unique_ptr<Type> fByte4_Type;
245
246 const std::unique_ptr<Type> fBool_Type;
247 const std::unique_ptr<Type> fBool2_Type;
248 const std::unique_ptr<Type> fBool3_Type;
249 const std::unique_ptr<Type> fBool4_Type;
250
251 const std::unique_ptr<Type> fFloat2x2_Type;
252 const std::unique_ptr<Type> fFloat2x3_Type;
253 const std::unique_ptr<Type> fFloat2x4_Type;
254 const std::unique_ptr<Type> fFloat3x2_Type;
255 const std::unique_ptr<Type> fFloat3x3_Type;
256 const std::unique_ptr<Type> fFloat3x4_Type;
257 const std::unique_ptr<Type> fFloat4x2_Type;
258 const std::unique_ptr<Type> fFloat4x3_Type;
259 const std::unique_ptr<Type> fFloat4x4_Type;
260
261 const std::unique_ptr<Type> fHalf2x2_Type;
262 const std::unique_ptr<Type> fHalf2x3_Type;
263 const std::unique_ptr<Type> fHalf2x4_Type;
264 const std::unique_ptr<Type> fHalf3x2_Type;
265 const std::unique_ptr<Type> fHalf3x3_Type;
266 const std::unique_ptr<Type> fHalf3x4_Type;
267 const std::unique_ptr<Type> fHalf4x2_Type;
268 const std::unique_ptr<Type> fHalf4x3_Type;
269 const std::unique_ptr<Type> fHalf4x4_Type;
270
271 const std::unique_ptr<Type> fDouble2x2_Type;
272 const std::unique_ptr<Type> fDouble2x3_Type;
273 const std::unique_ptr<Type> fDouble2x4_Type;
274 const std::unique_ptr<Type> fDouble3x2_Type;
275 const std::unique_ptr<Type> fDouble3x3_Type;
276 const std::unique_ptr<Type> fDouble3x4_Type;
277 const std::unique_ptr<Type> fDouble4x2_Type;
278 const std::unique_ptr<Type> fDouble4x3_Type;
279 const std::unique_ptr<Type> fDouble4x4_Type;
280
281 const std::unique_ptr<Type> fTexture1D_Type;
282 const std::unique_ptr<Type> fTexture2D_Type;
283 const std::unique_ptr<Type> fTexture3D_Type;
284 const std::unique_ptr<Type> fTextureExternalOES_Type;
285 const std::unique_ptr<Type> fTextureCube_Type;
286 const std::unique_ptr<Type> fTexture2DRect_Type;
287 const std::unique_ptr<Type> fTextureBuffer_Type;
288 const std::unique_ptr<Type> fITexture2D_Type;
289
290 const std::unique_ptr<Type> fSampler1D_Type;
291 const std::unique_ptr<Type> fSampler2D_Type;
292 const std::unique_ptr<Type> fSampler3D_Type;
293 const std::unique_ptr<Type> fSamplerExternalOES_Type;
294 const std::unique_ptr<Type> fSamplerCube_Type;
295 const std::unique_ptr<Type> fSampler2DRect_Type;
296 const std::unique_ptr<Type> fSampler1DArray_Type;
297 const std::unique_ptr<Type> fSampler2DArray_Type;
298 const std::unique_ptr<Type> fSamplerCubeArray_Type;
299 const std::unique_ptr<Type> fSamplerBuffer_Type;
300 const std::unique_ptr<Type> fSampler2DMS_Type;
301 const std::unique_ptr<Type> fSampler2DMSArray_Type;
302 const std::unique_ptr<Type> fSampler1DShadow_Type;
303 const std::unique_ptr<Type> fSampler2DShadow_Type;
304 const std::unique_ptr<Type> fSamplerCubeShadow_Type;
305 const std::unique_ptr<Type> fSampler2DRectShadow_Type;
306 const std::unique_ptr<Type> fSampler1DArrayShadow_Type;
307 const std::unique_ptr<Type> fSampler2DArrayShadow_Type;
308 const std::unique_ptr<Type> fSamplerCubeArrayShadow_Type;
309
310 const std::unique_ptr<Type> fISampler2D_Type;
311 const std::unique_ptr<Type> fSampler_Type;
312
313 const std::unique_ptr<Type> fImage2D_Type;
314 const std::unique_ptr<Type> fIImage2D_Type;
315
316 const std::unique_ptr<Type> fSubpassInput_Type;
317 const std::unique_ptr<Type> fSubpassInputMS_Type;
318
319 const std::unique_ptr<Type> fGSampler1D_Type;
320 const std::unique_ptr<Type> fGSampler2D_Type;
321 const std::unique_ptr<Type> fGSampler3D_Type;
322 const std::unique_ptr<Type> fGSamplerCube_Type;
323 const std::unique_ptr<Type> fGSampler2DRect_Type;
324 const std::unique_ptr<Type> fGSampler1DArray_Type;
325 const std::unique_ptr<Type> fGSampler2DArray_Type;
326 const std::unique_ptr<Type> fGSamplerCubeArray_Type;
327 const std::unique_ptr<Type> fGSamplerBuffer_Type;
328 const std::unique_ptr<Type> fGSampler2DMS_Type;
329 const std::unique_ptr<Type> fGSampler2DMSArray_Type;
330 const std::unique_ptr<Type> fGSampler2DArrayShadow_Type;
331 const std::unique_ptr<Type> fGSamplerCubeArrayShadow_Type;
332
333 const std::unique_ptr<Type> fGenType_Type;
334 const std::unique_ptr<Type> fGenHType_Type;
335 const std::unique_ptr<Type> fGenIType_Type;
336 const std::unique_ptr<Type> fGenUType_Type;
337 const std::unique_ptr<Type> fGenBType_Type;
338
339 const std::unique_ptr<Type> fMat_Type;
340
341 const std::unique_ptr<Type> fVec_Type;
342
343 const std::unique_ptr<Type> fGVec_Type;
344 const std::unique_ptr<Type> fGVec2_Type;
345 const std::unique_ptr<Type> fGVec3_Type;
346 const std::unique_ptr<Type> fGVec4_Type;
347 const std::unique_ptr<Type> fHVec_Type;
348 const std::unique_ptr<Type> fDVec_Type;
349 const std::unique_ptr<Type> fIVec_Type;
350 const std::unique_ptr<Type> fUVec_Type;
351 const std::unique_ptr<Type> fSVec_Type;
352 const std::unique_ptr<Type> fUSVec_Type;
353 const std::unique_ptr<Type> fByteVec_Type;
354 const std::unique_ptr<Type> fUByteVec_Type;
355
356 const std::unique_ptr<Type> fBVec_Type;
357
358 const std::unique_ptr<Type> fSkCaps_Type;
359 const std::unique_ptr<Type> fFragmentProcessor_Type;
360
361 // sentinel expression used to mark that a variable has a value during dataflow analysis (when
362 // it could have several different values, or the analyzer is otherwise unable to assign it a
363 // specific expression)
364 const std::unique_ptr<Expression> fDefined_Expression;
365
366private:
367 class Defined : public Expression {
368 public:
369 Defined(const Type& type)
370 : INHERITED(-1, kDefined_Kind, type) {}
371
372 bool hasProperty(Property property) const override {
373 return false;
374 }
375
376 String description() const override {
377 return "<defined>";
378 }
379
380 int nodeCount() const override {
381 SkASSERT(false);
382 return 1;
383 }
384
385 std::unique_ptr<Expression> clone() const override {
386 return std::unique_ptr<Expression>(new Defined(fType));
387 }
388
389 typedef Expression INHERITED;
390 };
391
392 static std::unique_ptr<Type> fp_type(const Type* intType, const Type* boolType) {
393 // Build fields for FragmentProcessors, which should parallel the
394 // C++ API for GrFragmentProcessor.
395 Modifiers mods(Layout(), Modifiers::kConst_Flag);
396 std::vector<Type::Field> fields = {
397 Type::Field(mods, "numTextureSamplers", intType),
398 Type::Field(mods, "numChildProcessors", intType),
399 Type::Field(mods, "usesLocalCoords", boolType),
400 Type::Field(mods, "compatibleWithCoverageAsAlpha", boolType),
401 Type::Field(mods, "preservesOpaqueInput", boolType),
402 Type::Field(mods, "hasConstantOutputForConstantInput", boolType)
403 };
404 return std::make_unique<Type>("fragmentProcessor", fields);
405 }
406};
407
408} // namespace SkSL
409
410#endif
411