1 /*
2 * Copyright 2012 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 GrGLUtil_DEFINED
9 #define GrGLUtil_DEFINED
10
11 #include "include/gpu/gl/GrGLInterface.h"
12 #include "include/private/gpu/ganesh/GrTypesPriv.h"
13 #include "src/core/SkImageInfoPriv.h"
14 #include "src/gpu/ganesh/GrDataUtils.h"
15 #include "src/gpu/ganesh/GrStencilSettings.h"
16 #include "src/gpu/ganesh/gl/GrGLDefines.h"
17
18 class SkMatrix;
19
20 ////////////////////////////////////////////////////////////////////////////////
21
22 typedef uint32_t GrGLVersion;
23 typedef uint32_t GrGLSLVersion;
24 typedef uint64_t GrGLDriverVersion;
25
26 #define GR_GL_VER(major, minor) ((static_cast<uint32_t>(major) << 16) | \
27 static_cast<uint32_t>(minor))
28 #define GR_GLSL_VER(major, minor) ((static_cast<uint32_t>(major) << 16) | \
29 static_cast<uint32_t>(minor))
30 #define GR_GL_DRIVER_VER(major, minor, point) ((static_cast<uint64_t>(major) << 32) | \
31 (static_cast<uint64_t>(minor) << 16) | \
32 static_cast<uint64_t>(point))
33
34 #define GR_GL_MAJOR_VER(version) (static_cast<uint32_t>(version) >> 16)
35 #define GR_GL_MINOR_VER(version) (static_cast<uint32_t>(version) & 0xFFFF)
36
37 #define GR_GL_INVALID_VER GR_GL_VER(0, 0)
38 #define GR_GLSL_INVALID_VER GR_GLSL_VER(0, 0)
39 #define GR_GL_DRIVER_UNKNOWN_VER GR_GL_DRIVER_VER(0, 0, 0)
40
GrGLFormatChannels(GrGLFormat format)41 static constexpr uint32_t GrGLFormatChannels(GrGLFormat format) {
42 switch (format) {
43 case GrGLFormat::kUnknown: return 0;
44 case GrGLFormat::kRGBA8: return kRGBA_SkColorChannelFlags;
45 case GrGLFormat::kR8: return kRed_SkColorChannelFlag;
46 case GrGLFormat::kALPHA8: return kAlpha_SkColorChannelFlag;
47 case GrGLFormat::kLUMINANCE8: return kGray_SkColorChannelFlag;
48 case GrGLFormat::kLUMINANCE8_ALPHA8: return kGrayAlpha_SkColorChannelFlags;
49 case GrGLFormat::kBGRA8: return kRGBA_SkColorChannelFlags;
50 case GrGLFormat::kRGB565: return kRGB_SkColorChannelFlags;
51 case GrGLFormat::kRGBA16F: return kRGBA_SkColorChannelFlags;
52 case GrGLFormat::kR16F: return kRed_SkColorChannelFlag;
53 case GrGLFormat::kRGB8: return kRGB_SkColorChannelFlags;
54 case GrGLFormat::kRGBX8: return kRGB_SkColorChannelFlags;
55 case GrGLFormat::kRG8: return kRG_SkColorChannelFlags;
56 case GrGLFormat::kRGB10_A2: return kRGBA_SkColorChannelFlags;
57 case GrGLFormat::kRGBA4: return kRGBA_SkColorChannelFlags;
58 case GrGLFormat::kSRGB8_ALPHA8: return kRGBA_SkColorChannelFlags;
59 case GrGLFormat::kCOMPRESSED_ETC1_RGB8: return kRGB_SkColorChannelFlags;
60 case GrGLFormat::kCOMPRESSED_RGB8_ETC2: return kRGB_SkColorChannelFlags;
61 case GrGLFormat::kCOMPRESSED_RGB8_BC1: return kRGB_SkColorChannelFlags;
62 case GrGLFormat::kCOMPRESSED_RGBA8_BC1: return kRGBA_SkColorChannelFlags;
63 case GrGLFormat::kR16: return kRed_SkColorChannelFlag;
64 case GrGLFormat::kRG16: return kRG_SkColorChannelFlags;
65 case GrGLFormat::kRGBA16: return kRGBA_SkColorChannelFlags;
66 case GrGLFormat::kRG16F: return kRG_SkColorChannelFlags;
67 case GrGLFormat::kLUMINANCE16F: return kGray_SkColorChannelFlag;
68 case GrGLFormat::kSTENCIL_INDEX8: return 0;
69 case GrGLFormat::kSTENCIL_INDEX16: return 0;
70 case GrGLFormat::kDEPTH24_STENCIL8: return 0;
71 }
72 SkUNREACHABLE;
73 }
74
GrGLFormatDesc(GrGLFormat format)75 static constexpr GrColorFormatDesc GrGLFormatDesc(GrGLFormat format) {
76 switch (format) {
77 case GrGLFormat::kUnknown: return GrColorFormatDesc::MakeInvalid();
78
79 case GrGLFormat::kRGBA8:
80 return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
81 case GrGLFormat::kR8:
82 return GrColorFormatDesc::MakeR(8, GrColorTypeEncoding::kUnorm);
83 case GrGLFormat::kALPHA8:
84 return GrColorFormatDesc::MakeAlpha(8, GrColorTypeEncoding::kUnorm);
85 case GrGLFormat::kLUMINANCE8:
86 return GrColorFormatDesc::MakeGray(8, GrColorTypeEncoding::kUnorm);
87 case GrGLFormat::kLUMINANCE8_ALPHA8:
88 return GrColorFormatDesc::MakeGrayAlpha(8, GrColorTypeEncoding::kUnorm);
89 case GrGLFormat::kBGRA8:
90 return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
91 case GrGLFormat::kRGB565:
92 return GrColorFormatDesc::MakeRGB(5, 6, 5, GrColorTypeEncoding::kUnorm);
93 case GrGLFormat::kRGBA16F:
94 return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
95 case GrGLFormat::kR16F:
96 return GrColorFormatDesc::MakeR(16, GrColorTypeEncoding::kFloat);
97 case GrGLFormat::kRGB8:
98 return GrColorFormatDesc::MakeRGB(8, GrColorTypeEncoding::kUnorm);
99 case GrGLFormat::kRGBX8:
100 return GrColorFormatDesc::MakeRGB(8, GrColorTypeEncoding::kUnorm);
101 case GrGLFormat::kRG8:
102 return GrColorFormatDesc::MakeRG(8, GrColorTypeEncoding::kUnorm);
103 case GrGLFormat::kRGB10_A2:
104 return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
105 case GrGLFormat::kRGBA4:
106 return GrColorFormatDesc::MakeRGBA(4, GrColorTypeEncoding::kUnorm);
107 case GrGLFormat::kSRGB8_ALPHA8:
108 return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kSRGBUnorm);
109 case GrGLFormat::kR16:
110 return GrColorFormatDesc::MakeR(16, GrColorTypeEncoding::kUnorm);
111 case GrGLFormat::kRG16:
112 return GrColorFormatDesc::MakeRG(16, GrColorTypeEncoding::kUnorm);
113 case GrGLFormat::kRGBA16:
114 return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kUnorm);
115 case GrGLFormat::kRG16F:
116 return GrColorFormatDesc::MakeRG(16, GrColorTypeEncoding::kFloat);
117 case GrGLFormat::kLUMINANCE16F:
118 return GrColorFormatDesc::MakeGray(16, GrColorTypeEncoding::kFloat);
119
120 // Compressed texture formats are not expected to have a description.
121 case GrGLFormat::kCOMPRESSED_ETC1_RGB8: return GrColorFormatDesc::MakeInvalid();
122 case GrGLFormat::kCOMPRESSED_RGB8_ETC2: return GrColorFormatDesc::MakeInvalid();
123 case GrGLFormat::kCOMPRESSED_RGB8_BC1: return GrColorFormatDesc::MakeInvalid();
124 case GrGLFormat::kCOMPRESSED_RGBA8_BC1: return GrColorFormatDesc::MakeInvalid();
125
126 // This type only describes color channels.
127 case GrGLFormat::kSTENCIL_INDEX8: return GrColorFormatDesc::MakeInvalid();
128 case GrGLFormat::kSTENCIL_INDEX16: return GrColorFormatDesc::MakeInvalid();
129 case GrGLFormat::kDEPTH24_STENCIL8: return GrColorFormatDesc::MakeInvalid();
130 }
131 SkUNREACHABLE;
132 }
133
134 /**
135 * The Vendor and Renderer enum values are lazily updated as required.
136 */
137 enum class GrGLVendor {
138 kARM,
139 kGoogle,
140 kImagination,
141 kIntel,
142 kQualcomm,
143 kNVIDIA,
144 kATI,
145 kApple,
146
147 kOther
148 };
149
150 enum class GrGLRenderer {
151 kTegra_PreK1, // Legacy Tegra architecture (pre-K1).
152 kTegra, // Tegra with the same architecture as NVIDIA desktop GPUs (K1+).
153
154 kPowerVR54x,
155 kPowerVRBSeries,
156 kPowerVRRogue,
157
158 kAdreno3xx,
159 kAdreno430,
160 kAdreno4xx_other,
161 kAdreno530,
162 kAdreno5xx_other,
163 kAdreno615, // Pixel3a
164 kAdreno620, // Pixel5
165 kAdreno630, // Pixel3
166 kAdreno640, // Pixel4
167 kAdreno6xx_other,
168
169 /** Intel GPU families, ordered by generation **/
170 // 6th gen
171 kIntelSandyBridge,
172
173 // 7th gen
174 kIntelIvyBridge,
175 kIntelValleyView, // aka BayTrail
176 kIntelHaswell,
177
178 // 8th gen
179 kIntelCherryView, // aka Braswell
180 kIntelBroadwell,
181
182 // 9th gen
183 kIntelApolloLake,
184 kIntelSkyLake,
185 kIntelGeminiLake,
186 kIntelKabyLake,
187 kIntelCoffeeLake,
188
189 // 11th gen
190 kIntelIceLake,
191
192 // 12th gen
193 kIntelRocketLake,
194 kIntelTigerLake,
195 kIntelAlderLake,
196
197 kGalliumLLVM,
198
199 kMali4xx,
200 /** G-3x, G-5x, or G-7x */
201 kMaliG,
202 /** T-6xx, T-7xx, or T-8xx */
203 kMaliT,
204
205 kAMDRadeonHD7xxx, // AMD Radeon HD 7000 Series
206 kAMDRadeonR9M3xx, // AMD Radeon R9 M300 Series
207 kAMDRadeonR9M4xx, // AMD Radeon R9 M400 Series
208 kAMDRadeonPro5xxx, // AMD Radeon Pro 5000 Series
209 kAMDRadeonProVegaxx, // AMD Radeon Pro Vega
210
211 kApple,
212
213 kWebGL,
214
215 kOther
216 };
217
218 enum class GrGLDriver {
219 kMesa,
220 kNVIDIA,
221 kIntel,
222 kQualcomm,
223 kFreedreno,
224 kAndroidEmulator,
225 kImagination,
226 kARM,
227 kApple,
228 kUnknown
229 };
230
231 enum class GrGLANGLEBackend {
232 kUnknown,
233 kD3D9,
234 kD3D11,
235 kMetal,
236 kOpenGL
237 };
238
239 ////////////////////////////////////////////////////////////////////////////////
240
241 /**
242 * Some drivers want the var-int arg to be zero-initialized on input.
243 */
244 #define GR_GL_INIT_ZERO 0
245 #define GR_GL_GetIntegerv(gl, e, p) \
246 do { \
247 *(p) = GR_GL_INIT_ZERO; \
248 GR_GL_CALL(gl, GetIntegerv(e, p)); \
249 } while (0)
250
251 #define GR_GL_GetFloatv(gl, e, p) \
252 do { \
253 *(p) = GR_GL_INIT_ZERO; \
254 GR_GL_CALL(gl, GetFloatv(e, p)); \
255 } while (0)
256
257 #define GR_GL_GetFramebufferAttachmentParameteriv(gl, t, a, pname, p) \
258 do { \
259 *(p) = GR_GL_INIT_ZERO; \
260 GR_GL_CALL(gl, GetFramebufferAttachmentParameteriv(t, a, pname, p)); \
261 } while (0)
262
263 #define GR_GL_GetInternalformativ(gl, t, f, n, s, p) \
264 do { \
265 *(p) = GR_GL_INIT_ZERO; \
266 GR_GL_CALL(gl, GetInternalformativ(t, f, n, s, p)); \
267 } while (0)
268
269 #define GR_GL_GetNamedFramebufferAttachmentParameteriv(gl, fb, a, pname, p) \
270 do { \
271 *(p) = GR_GL_INIT_ZERO; \
272 GR_GL_CALL(gl, GetNamedFramebufferAttachmentParameteriv(fb, a, pname, p)); \
273 } while (0)
274
275 #define GR_GL_GetRenderbufferParameteriv(gl, t, pname, p) \
276 do { \
277 *(p) = GR_GL_INIT_ZERO; \
278 GR_GL_CALL(gl, GetRenderbufferParameteriv(t, pname, p)); \
279 } while (0)
280
281 #define GR_GL_GetTexLevelParameteriv(gl, t, l, pname, p) \
282 do { \
283 *(p) = GR_GL_INIT_ZERO; \
284 GR_GL_CALL(gl, GetTexLevelParameteriv(t, l, pname, p)); \
285 } while (0)
286
287 #define GR_GL_GetShaderPrecisionFormat(gl, st, pt, range, precision) \
288 do { \
289 (range)[0] = GR_GL_INIT_ZERO; \
290 (range)[1] = GR_GL_INIT_ZERO; \
291 (*precision) = GR_GL_INIT_ZERO; \
292 GR_GL_CALL(gl, GetShaderPrecisionFormat(st, pt, range, precision)); \
293 } while (0)
294
295 ////////////////////////////////////////////////////////////////////////////////
296
297 GrGLStandard GrGLGetStandardInUseFromString(const char* versionString);
298 GrGLSLVersion GrGLGetVersion(const GrGLInterface*);
299 GrGLSLVersion GrGLGetVersionFromString(const char*);
300
301 struct GrGLDriverInfo {
302 GrGLStandard fStandard = kNone_GrGLStandard;
303 GrGLVersion fVersion = GR_GL_INVALID_VER;
304 GrGLSLVersion fGLSLVersion = GR_GLSL_INVALID_VER;
305 GrGLVendor fVendor = GrGLVendor::kOther;
306 GrGLRenderer fRenderer = GrGLRenderer::kOther;
307 GrGLDriver fDriver = GrGLDriver::kUnknown;
308 GrGLDriverVersion fDriverVersion = GR_GL_DRIVER_UNKNOWN_VER;
309
310 GrGLANGLEBackend fANGLEBackend = GrGLANGLEBackend::kUnknown;
311 GrGLVendor fANGLEVendor = GrGLVendor::kOther;
312 GrGLRenderer fANGLERenderer = GrGLRenderer::kOther;
313 GrGLDriver fANGLEDriver = GrGLDriver::kUnknown;
314 GrGLDriverVersion fANGLEDriverVersion = GR_GL_DRIVER_UNKNOWN_VER;
315
316 GrGLVendor fWebGLVendor = GrGLVendor::kOther;
317 GrGLRenderer fWebGLRenderer = GrGLRenderer::kOther;
318
319 // Are we running over the Chrome interprocess command buffer?
320 bool fIsOverCommandBuffer = false;
321
322 // Running over virgl guest driver.
323 bool fIsRunningOverVirgl = false;
324 };
325
326 GrGLDriverInfo GrGLGetDriverInfo(const GrGLInterface*);
327
328 /**
329 * Helpers for glGetError()
330 */
331
332 void GrGLCheckErr(const GrGLInterface* gl,
333 const char* location,
334 const char* call);
335
336 ////////////////////////////////////////////////////////////////////////////////
337
338 /**
339 * GR_STRING makes a string of X where X is expanded before conversion to a string
340 * if X itself contains macros.
341 */
342 #define GR_STRING(X) GR_STRING_IMPL(X)
343 #define GR_STRING_IMPL(X) #X
344
345 /**
346 * Creates a string of the form "<filename>(<linenumber>) : "
347 */
348 #define GR_FILE_AND_LINE_STR __FILE__ "(" GR_STRING(__LINE__) ") : "
349
350 /**
351 * Macros for using GrGLInterface to make GL calls
352 */
353
354 // Conditionally checks glGetError based on compile-time and run-time flags.
355 #if GR_GL_CHECK_ERROR
356 extern bool gCheckErrorGL;
357 #define GR_GL_CHECK_ERROR_IMPL(IFACE, X) \
358 do { \
359 if (gCheckErrorGL) { \
360 IFACE->checkError(GR_FILE_AND_LINE_STR, #X); \
361 } \
362 } while (false)
363 #else
364 #define GR_GL_CHECK_ERROR_IMPL(IFACE, X) \
365 do { \
366 } while (false)
367 #endif
368
369 // internal macro to conditionally log the gl call using SkDebugf based on
370 // compile-time and run-time flags.
371 #if GR_GL_LOG_CALLS
372 extern bool gLogCallsGL;
373 #define GR_GL_LOG_CALLS_IMPL(X) \
374 if (gLogCallsGL) \
375 SkDebugf(GR_FILE_AND_LINE_STR "GL: " #X "\n")
376 #else
377 #define GR_GL_LOG_CALLS_IMPL(X)
378 #endif
379
380 // makes a GL call on the interface and does any error checking and logging
381 #define GR_GL_CALL(IFACE, X) \
382 do { \
383 GR_GL_CALL_NOERRCHECK(IFACE, X); \
384 GR_GL_CHECK_ERROR_IMPL(IFACE, X); \
385 } while (false)
386
387 // Variant of above that always skips the error check. This is useful when
388 // the caller wants to do its own glGetError() call and examine the error value.
389 #define GR_GL_CALL_NOERRCHECK(IFACE, X) \
390 do { \
391 (IFACE)->fFunctions.f##X; \
392 GR_GL_LOG_CALLS_IMPL(X); \
393 } while (false)
394
395 // same as GR_GL_CALL but stores the return value of the gl call in RET
396 #define GR_GL_CALL_RET(IFACE, RET, X) \
397 do { \
398 GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X); \
399 GR_GL_CHECK_ERROR_IMPL(IFACE, X); \
400 } while (false)
401
402 // same as GR_GL_CALL_RET but always skips the error check.
403 #define GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X) \
404 do { \
405 (RET) = (IFACE)->fFunctions.f##X; \
406 GR_GL_LOG_CALLS_IMPL(X); \
407 } while (false)
408
GrGLFormatFromGLEnum(GrGLenum glFormat)409 static constexpr GrGLFormat GrGLFormatFromGLEnum(GrGLenum glFormat) {
410 switch (glFormat) {
411 case GR_GL_RGBA8: return GrGLFormat::kRGBA8;
412 case GR_GL_R8: return GrGLFormat::kR8;
413 case GR_GL_ALPHA8: return GrGLFormat::kALPHA8;
414 case GR_GL_LUMINANCE8: return GrGLFormat::kLUMINANCE8;
415 case GR_GL_LUMINANCE8_ALPHA8: return GrGLFormat::kLUMINANCE8_ALPHA8;
416 case GR_GL_BGRA8: return GrGLFormat::kBGRA8;
417 case GR_GL_RGB565: return GrGLFormat::kRGB565;
418 case GR_GL_RGBA16F: return GrGLFormat::kRGBA16F;
419 case GR_GL_LUMINANCE16F: return GrGLFormat::kLUMINANCE16F;
420 case GR_GL_R16F: return GrGLFormat::kR16F;
421 case GR_GL_RGB8: return GrGLFormat::kRGB8;
422 case GR_GL_RGBX8: return GrGLFormat::kRGBX8;
423 case GR_GL_RG8: return GrGLFormat::kRG8;
424 case GR_GL_RGB10_A2: return GrGLFormat::kRGB10_A2;
425 case GR_GL_RGBA4: return GrGLFormat::kRGBA4;
426 case GR_GL_SRGB8_ALPHA8: return GrGLFormat::kSRGB8_ALPHA8;
427 case GR_GL_COMPRESSED_ETC1_RGB8: return GrGLFormat::kCOMPRESSED_ETC1_RGB8;
428 case GR_GL_COMPRESSED_RGB8_ETC2: return GrGLFormat::kCOMPRESSED_RGB8_ETC2;
429 case GR_GL_COMPRESSED_RGB_S3TC_DXT1_EXT: return GrGLFormat::kCOMPRESSED_RGB8_BC1;
430 case GR_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: return GrGLFormat::kCOMPRESSED_RGBA8_BC1;
431 case GR_GL_R16: return GrGLFormat::kR16;
432 case GR_GL_RG16: return GrGLFormat::kRG16;
433 case GR_GL_RGBA16: return GrGLFormat::kRGBA16;
434 case GR_GL_RG16F: return GrGLFormat::kRG16F;
435 case GR_GL_STENCIL_INDEX8: return GrGLFormat::kSTENCIL_INDEX8;
436 case GR_GL_STENCIL_INDEX16: return GrGLFormat::kSTENCIL_INDEX16;
437 case GR_GL_DEPTH24_STENCIL8: return GrGLFormat::kDEPTH24_STENCIL8;
438
439
440 default: return GrGLFormat::kUnknown;
441 }
442 }
443
444 /** Returns either the sized internal format or compressed internal format of the GrGLFormat. */
GrGLFormatToEnum(GrGLFormat format)445 static constexpr GrGLenum GrGLFormatToEnum(GrGLFormat format) {
446 switch (format) {
447 case GrGLFormat::kRGBA8: return GR_GL_RGBA8;
448 case GrGLFormat::kR8: return GR_GL_R8;
449 case GrGLFormat::kALPHA8: return GR_GL_ALPHA8;
450 case GrGLFormat::kLUMINANCE8: return GR_GL_LUMINANCE8;
451 case GrGLFormat::kLUMINANCE8_ALPHA8: return GR_GL_LUMINANCE8_ALPHA8;
452 case GrGLFormat::kBGRA8: return GR_GL_BGRA8;
453 case GrGLFormat::kRGB565: return GR_GL_RGB565;
454 case GrGLFormat::kRGBA16F: return GR_GL_RGBA16F;
455 case GrGLFormat::kLUMINANCE16F: return GR_GL_LUMINANCE16F;
456 case GrGLFormat::kR16F: return GR_GL_R16F;
457 case GrGLFormat::kRGB8: return GR_GL_RGB8;
458 case GrGLFormat::kRGBX8: return GR_GL_RGBX8;
459 case GrGLFormat::kRG8: return GR_GL_RG8;
460 case GrGLFormat::kRGB10_A2: return GR_GL_RGB10_A2;
461 case GrGLFormat::kRGBA4: return GR_GL_RGBA4;
462 case GrGLFormat::kSRGB8_ALPHA8: return GR_GL_SRGB8_ALPHA8;
463 case GrGLFormat::kCOMPRESSED_ETC1_RGB8: return GR_GL_COMPRESSED_ETC1_RGB8;
464 case GrGLFormat::kCOMPRESSED_RGB8_ETC2: return GR_GL_COMPRESSED_RGB8_ETC2;
465 case GrGLFormat::kCOMPRESSED_RGB8_BC1: return GR_GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
466 case GrGLFormat::kCOMPRESSED_RGBA8_BC1: return GR_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
467 case GrGLFormat::kR16: return GR_GL_R16;
468 case GrGLFormat::kRG16: return GR_GL_RG16;
469 case GrGLFormat::kRGBA16: return GR_GL_RGBA16;
470 case GrGLFormat::kRG16F: return GR_GL_RG16F;
471 case GrGLFormat::kSTENCIL_INDEX8: return GR_GL_STENCIL_INDEX8;
472 case GrGLFormat::kSTENCIL_INDEX16: return GR_GL_STENCIL_INDEX16;
473 case GrGLFormat::kDEPTH24_STENCIL8: return GR_GL_DEPTH24_STENCIL8;
474 case GrGLFormat::kUnknown: return 0;
475 }
476 SkUNREACHABLE;
477 }
478
GrGLFormatBytesPerBlock(GrGLFormat format)479 static constexpr size_t GrGLFormatBytesPerBlock(GrGLFormat format) {
480 switch (format) {
481 case GrGLFormat::kRGBA8: return 4;
482 case GrGLFormat::kR8: return 1;
483 case GrGLFormat::kALPHA8: return 1;
484 case GrGLFormat::kLUMINANCE8: return 1;
485 case GrGLFormat::kLUMINANCE8_ALPHA8: return 2;
486 case GrGLFormat::kBGRA8: return 4;
487 case GrGLFormat::kRGB565: return 2;
488 case GrGLFormat::kRGBA16F: return 8;
489 case GrGLFormat::kLUMINANCE16F: return 2;
490 case GrGLFormat::kR16F: return 2;
491 // We assume the GPU stores this format 4 byte aligned
492 case GrGLFormat::kRGB8: return 4;
493 case GrGLFormat::kRGBX8: return 4;
494 case GrGLFormat::kRG8: return 2;
495 case GrGLFormat::kRGB10_A2: return 4;
496 case GrGLFormat::kRGBA4: return 2;
497 case GrGLFormat::kSRGB8_ALPHA8: return 4;
498 case GrGLFormat::kCOMPRESSED_ETC1_RGB8: return 8;
499 case GrGLFormat::kCOMPRESSED_RGB8_ETC2: return 8;
500 case GrGLFormat::kCOMPRESSED_RGB8_BC1: return 8;
501 case GrGLFormat::kCOMPRESSED_RGBA8_BC1: return 8;
502 case GrGLFormat::kR16: return 2;
503 case GrGLFormat::kRG16: return 4;
504 case GrGLFormat::kRGBA16: return 8;
505 case GrGLFormat::kRG16F: return 4;
506 case GrGLFormat::kSTENCIL_INDEX8: return 1;
507 case GrGLFormat::kSTENCIL_INDEX16: return 2;
508 case GrGLFormat::kDEPTH24_STENCIL8: return 4;
509 case GrGLFormat::kUnknown: return 0;
510 }
511 SkUNREACHABLE;
512 }
513
GrGLFormatStencilBits(GrGLFormat format)514 static constexpr int GrGLFormatStencilBits(GrGLFormat format) {
515 switch (format) {
516 case GrGLFormat::kSTENCIL_INDEX8:
517 return 8;
518 case GrGLFormat::kSTENCIL_INDEX16:
519 return 16;
520 case GrGLFormat::kDEPTH24_STENCIL8:
521 return 8;
522 case GrGLFormat::kCOMPRESSED_ETC1_RGB8:
523 case GrGLFormat::kCOMPRESSED_RGB8_ETC2:
524 case GrGLFormat::kCOMPRESSED_RGB8_BC1:
525 case GrGLFormat::kCOMPRESSED_RGBA8_BC1:
526 case GrGLFormat::kRGBA8:
527 case GrGLFormat::kR8:
528 case GrGLFormat::kALPHA8:
529 case GrGLFormat::kLUMINANCE8:
530 case GrGLFormat::kLUMINANCE8_ALPHA8:
531 case GrGLFormat::kBGRA8:
532 case GrGLFormat::kRGB565:
533 case GrGLFormat::kRGBA16F:
534 case GrGLFormat::kR16F:
535 case GrGLFormat::kLUMINANCE16F:
536 case GrGLFormat::kRGB8:
537 case GrGLFormat::kRGBX8:
538 case GrGLFormat::kRG8:
539 case GrGLFormat::kRGB10_A2:
540 case GrGLFormat::kRGBA4:
541 case GrGLFormat::kSRGB8_ALPHA8:
542 case GrGLFormat::kR16:
543 case GrGLFormat::kRG16:
544 case GrGLFormat::kRGBA16:
545 case GrGLFormat::kRG16F:
546 case GrGLFormat::kUnknown:
547 return 0;
548 }
549 SkUNREACHABLE;
550 }
551
GrGLFormatIsPackedDepthStencil(GrGLFormat format)552 static constexpr bool GrGLFormatIsPackedDepthStencil(GrGLFormat format) {
553 switch (format) {
554 case GrGLFormat::kDEPTH24_STENCIL8:
555 return true;
556 case GrGLFormat::kCOMPRESSED_ETC1_RGB8:
557 case GrGLFormat::kCOMPRESSED_RGB8_ETC2:
558 case GrGLFormat::kCOMPRESSED_RGB8_BC1:
559 case GrGLFormat::kCOMPRESSED_RGBA8_BC1:
560 case GrGLFormat::kRGBA8:
561 case GrGLFormat::kR8:
562 case GrGLFormat::kALPHA8:
563 case GrGLFormat::kLUMINANCE8:
564 case GrGLFormat::kLUMINANCE8_ALPHA8:
565 case GrGLFormat::kBGRA8:
566 case GrGLFormat::kRGB565:
567 case GrGLFormat::kRGBA16F:
568 case GrGLFormat::kR16F:
569 case GrGLFormat::kLUMINANCE16F:
570 case GrGLFormat::kRGB8:
571 case GrGLFormat::kRGBX8:
572 case GrGLFormat::kRG8:
573 case GrGLFormat::kRGB10_A2:
574 case GrGLFormat::kRGBA4:
575 case GrGLFormat::kSRGB8_ALPHA8:
576 case GrGLFormat::kR16:
577 case GrGLFormat::kRG16:
578 case GrGLFormat::kRGBA16:
579 case GrGLFormat::kRG16F:
580 case GrGLFormat::kSTENCIL_INDEX8:
581 case GrGLFormat::kSTENCIL_INDEX16:
582 case GrGLFormat::kUnknown:
583 return false;
584 }
585 SkUNREACHABLE;
586 }
587
GrGLFormatIsSRGB(GrGLFormat format)588 static constexpr bool GrGLFormatIsSRGB(GrGLFormat format) {
589 switch (format) {
590 case GrGLFormat::kSRGB8_ALPHA8:
591 return true;
592 case GrGLFormat::kCOMPRESSED_ETC1_RGB8:
593 case GrGLFormat::kCOMPRESSED_RGB8_ETC2:
594 case GrGLFormat::kCOMPRESSED_RGB8_BC1:
595 case GrGLFormat::kCOMPRESSED_RGBA8_BC1:
596 case GrGLFormat::kRGBA8:
597 case GrGLFormat::kR8:
598 case GrGLFormat::kALPHA8:
599 case GrGLFormat::kLUMINANCE8:
600 case GrGLFormat::kLUMINANCE8_ALPHA8:
601 case GrGLFormat::kBGRA8:
602 case GrGLFormat::kRGB565:
603 case GrGLFormat::kRGBA16F:
604 case GrGLFormat::kR16F:
605 case GrGLFormat::kLUMINANCE16F:
606 case GrGLFormat::kRGB8:
607 case GrGLFormat::kRGBX8:
608 case GrGLFormat::kRG8:
609 case GrGLFormat::kRGB10_A2:
610 case GrGLFormat::kRGBA4:
611 case GrGLFormat::kR16:
612 case GrGLFormat::kRG16:
613 case GrGLFormat::kRGBA16:
614 case GrGLFormat::kRG16F:
615 case GrGLFormat::kSTENCIL_INDEX8:
616 case GrGLFormat::kSTENCIL_INDEX16:
617 case GrGLFormat::kDEPTH24_STENCIL8:
618 case GrGLFormat::kUnknown:
619 return false;
620 }
621 SkUNREACHABLE;
622 }
623
624 #if defined(SK_DEBUG) || defined(GR_TEST_UTILS)
GrGLFormatToStr(GrGLenum glFormat)625 static constexpr const char* GrGLFormatToStr(GrGLenum glFormat) {
626 switch (glFormat) {
627 case GR_GL_RGBA8: return "RGBA8";
628 case GR_GL_R8: return "R8";
629 case GR_GL_ALPHA8: return "ALPHA8";
630 case GR_GL_LUMINANCE8: return "LUMINANCE8";
631 case GR_GL_LUMINANCE8_ALPHA8: return "LUMINANCE8_ALPHA8";
632 case GR_GL_BGRA8: return "BGRA8";
633 case GR_GL_RGB565: return "RGB565";
634 case GR_GL_RGBA16F: return "RGBA16F";
635 case GR_GL_LUMINANCE16F: return "LUMINANCE16F";
636 case GR_GL_R16F: return "R16F";
637 case GR_GL_RGB8: return "RGB8";
638 case GR_GL_RG8: return "RG8";
639 case GR_GL_RGB10_A2: return "RGB10_A2";
640 case GR_GL_RGBA4: return "RGBA4";
641 case GR_GL_RGBA32F: return "RGBA32F";
642 case GR_GL_SRGB8_ALPHA8: return "SRGB8_ALPHA8";
643 case GR_GL_COMPRESSED_ETC1_RGB8: return "ETC1";
644 case GR_GL_COMPRESSED_RGB8_ETC2: return "ETC2";
645 case GR_GL_COMPRESSED_RGB_S3TC_DXT1_EXT: return "RGB8_BC1";
646 case GR_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: return "RGBA8_BC1";
647 case GR_GL_R16: return "R16";
648 case GR_GL_RG16: return "RG16";
649 case GR_GL_RGBA16: return "RGBA16";
650 case GR_GL_RG16F: return "RG16F";
651 case GR_GL_STENCIL_INDEX8: return "STENCIL_INDEX8";
652 case GR_GL_STENCIL_INDEX16: return "STENCIL_INDEX16";
653 case GR_GL_DEPTH24_STENCIL8: return "DEPTH24_STENCIL8";
654
655 default: return "Unknown";
656 }
657 }
658 #endif
659
660 GrGLenum GrToGLStencilFunc(GrStencilTest test);
661
662 /**
663 * Returns true if the format is compressed.
664 */
665 bool GrGLFormatIsCompressed(GrGLFormat);
666
667 #endif
668