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