5756029fb538fd0a6f0c3b3aa39b05ebf7e2e4a4
[WebKit-https.git] / Source / ThirdParty / ANGLE / include / platform / FeaturesGL.h
1 //
2 // Copyright 2015 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 // FeaturesGL.h: Features and workarounds for GL driver bugs and other issues.
8
9 #ifndef ANGLE_PLATFORM_FEATURESGL_H_
10 #define ANGLE_PLATFORM_FEATURESGL_H_
11
12 #include "platform/Feature.h"
13
14 namespace angle
15 {
16
17 struct FeaturesGL : FeatureSetBase
18 {
19     FeaturesGL();
20     ~FeaturesGL();
21
22     // When writing a float to a normalized integer framebuffer, desktop OpenGL is allowed to write
23     // one of the two closest normalized integer representations (although round to nearest is
24     // preferred) (see section 2.3.5.2 of the GL 4.5 core specification). OpenGL ES requires that
25     // round-to-nearest is used (see "Conversion from Floating-Point to Framebuffer Fixed-Point" in
26     // section 2.1.2 of the OpenGL ES 2.0.25 spec).  This issue only shows up on AMD drivers on
27     // framebuffer formats that have 1-bit alpha, work around this by using higher precision formats
28     // instead.
29     Feature avoid1BitAlphaTextureFormats = {"avoid_1_bit_alpha_texture_formats",
30                                             FeatureCategory::OpenGLWorkarounds,
31                                             "Issue with 1-bit alpha framebuffer formats", &members};
32
33     // On some older Intel drivers, GL_RGBA4 is not color renderable, glCheckFramebufferStatus
34     // returns GL_FRAMEBUFFER_UNSUPPORTED. Work around this by using a known color-renderable
35     // format.
36     Feature rgba4IsNotSupportedForColorRendering = {"rgba4_is_not_supported_for_color_rendering",
37                                                     FeatureCategory::OpenGLWorkarounds,
38                                                     "GL_RGBA4 is not color renderable", &members};
39
40     // When clearing a framebuffer on Intel or AMD drivers, when GL_FRAMEBUFFER_SRGB is enabled, the
41     // driver clears to the linearized clear color despite the framebuffer not supporting SRGB
42     // blending.  It only seems to do this when the framebuffer has only linear attachments, mixed
43     // attachments appear to get the correct clear color.
44     Feature doesSRGBClearsOnLinearFramebufferAttachments = {
45         "does_srgb_clears_on_linear_framebuffer_attachments", FeatureCategory::OpenGLWorkarounds,
46         "Issue clearing framebuffers with linear attachments when GL_FRAMEBUFFER_SRGB is enabled",
47         &members};
48
49     // On Mac some GLSL constructs involving do-while loops cause GPU hangs, such as the following:
50     //  int i = 1;
51     //  do {
52     //      i --;
53     //      continue;
54     //  } while (i > 0)
55     // Work around this by rewriting the do-while to use another GLSL construct (block + while)
56     Feature doWhileGLSLCausesGPUHang = {
57         "do_while_glsl_causes_gpu_hang", FeatureCategory::OpenGLWorkarounds,
58         "Some GLSL constructs involving do-while loops cause GPU hangs", &members,
59         "http://crbug.com/644669"};
60
61     // On Mac AMD GPU gl_VertexID in GLSL vertex shader doesn't include base vertex value,
62     // Work aronud this by replace gl_VertexID with (gl_VertexID - angle_BaseVertex) when
63     // angle_BaseVertex is present.
64     Feature addBaseVertexToVertexID = {
65         "vertex_id_does_not_include_base_vertex", FeatureCategory::OpenGLWorkarounds,
66         "gl_VertexID in GLSL vertex shader doesn't include base vertex value", &members};
67
68     // Calling glFinish doesn't cause all queries to report that the result is available on some
69     // (NVIDIA) drivers.  It was found that enabling GL_DEBUG_OUTPUT_SYNCHRONOUS before the finish
70     // causes it to fully finish.
71     Feature finishDoesNotCauseQueriesToBeAvailable = {
72         "finish_does_not_cause_queries_to_be_available", FeatureCategory::OpenGLWorkarounds,
73         "glFinish doesn't cause all queries to report available result", &members};
74
75     // Always call useProgram after a successful link to avoid a driver bug.
76     // This workaround is meant to reproduce the use_current_program_after_successful_link
77     // workaround in Chromium (http://crbug.com/110263). It has been shown that this workaround is
78     // not necessary for MacOSX 10.9 and higher (http://crrev.com/39eb535b).
79     Feature alwaysCallUseProgramAfterLink = {
80         "always_call_use_program_after_link", FeatureCategory::OpenGLWorkarounds,
81         "Always call useProgram after a successful link to avoid a driver bug", &members,
82         "http://crbug.com/110263"};
83
84     // On NVIDIA, in the case of unpacking from a pixel unpack buffer, unpack overlapping rows row
85     // by row.
86     Feature unpackOverlappingRowsSeparatelyUnpackBuffer = {
87         "unpack_overlapping_rows_separately_unpack_buffer", FeatureCategory::OpenGLWorkarounds,
88         "In the case of unpacking from a pixel unpack buffer, unpack overlapping rows row by row",
89         &members};
90
91     // On NVIDIA, in the case of packing to a pixel pack buffer, pack overlapping rows row by row.
92     Feature packOverlappingRowsSeparatelyPackBuffer = {
93         "pack_overlapping_rows_separately_pack_buffer", FeatureCategory::OpenGLWorkarounds,
94         "In the case of packing to a pixel pack buffer, pack overlapping rows row by row",
95         &members};
96
97     // On NVIDIA, during initialization, assign the current vertex attributes to the spec-mandated
98     // defaults.
99     Feature initializeCurrentVertexAttributes = {
100         "initialize_current_vertex_attributes", FeatureCategory::OpenGLWorkarounds,
101         "During initialization, assign the current vertex attributes to the spec-mandated defaults",
102         &members};
103
104     // abs(i) where i is an integer returns unexpected result on Intel Mac.
105     // Emulate abs(i) with i * sign(i).
106     Feature emulateAbsIntFunction = {"emulate_abs_int_function", FeatureCategory::OpenGLWorkarounds,
107                                      "abs(i) where i is an integer returns unexpected result",
108                                      &members, "http://crbug.com/642227"};
109
110     // On Intel Mac, calculation of loop conditions in for and while loop has bug.
111     // Add "&& true" to the end of the condition expression to work around the bug.
112     Feature addAndTrueToLoopCondition = {
113         "add_and_true_to_loop_condition", FeatureCategory::OpenGLWorkarounds,
114         "Calculation of loop conditions in for and while loop has bug", &members};
115
116     // When uploading textures from an unpack buffer, some drivers count an extra row padding when
117     // checking if the pixel unpack buffer is big enough. Tracking bug: http://anglebug.com/1512
118     // For example considering the pixel buffer below where in memory, each row data (D) of the
119     // texture is followed by some unused data (the dots):
120     //     +-------+--+
121     //     |DDDDDDD|..|
122     //     |DDDDDDD|..|
123     //     |DDDDDDD|..|
124     //     |DDDDDDD|..|
125     //     +-------A--B
126     // The last pixel read will be A, but the driver will think it is B, causing it to generate an
127     // error when the pixel buffer is just big enough.
128     Feature unpackLastRowSeparatelyForPaddingInclusion = {
129         "unpack_last_row_separately_for_padding_inclusion", FeatureCategory::OpenGLWorkarounds,
130         "When uploading textures from an unpack buffer, some drivers count an extra row padding",
131         &members, "http://anglebug.com/1512"};
132
133     // Equivalent workaround when uploading data from a pixel pack buffer.
134     Feature packLastRowSeparatelyForPaddingInclusion = {
135         "pack_last_row_separately_for_padding_inclusion", FeatureCategory::OpenGLWorkarounds,
136         "When uploading textures from an pack buffer, some drivers count an extra row padding",
137         &members, "http://anglebug.com/1512"};
138
139     // On some Intel drivers, using isnan() on highp float will get wrong answer. To work around
140     // this bug, we use an expression to emulate function isnan().
141     // Tracking bug: http://crbug.com/650547
142     Feature emulateIsnanFloat = {"emulate_isnan_float", FeatureCategory::OpenGLWorkarounds,
143                                  "Using isnan() on highp float will get wrong answer", &members,
144                                  "http://crbug.com/650547"};
145
146     // On Mac with OpenGL version 4.1, unused std140 or shared uniform blocks will be
147     // treated as inactive which is not consistent with WebGL2.0 spec. Reference all members in a
148     // unused std140 or shared uniform block at the beginning of main to work around it.
149     // Also used on Linux AMD.
150     Feature useUnusedBlocksWithStandardOrSharedLayout = {
151         "use_unused_blocks_with_standard_or_shared_layout", FeatureCategory::OpenGLWorkarounds,
152         "Unused std140 or shared uniform blocks will be treated as inactive", &members};
153
154     // This flag is used to fix spec difference between GLSL 4.1 or lower and ESSL3.
155     Feature removeInvariantAndCentroidForESSL3 = {
156         "remove_invarient_and_centroid_for_essl3", FeatureCategory::OpenGLWorkarounds,
157         "Fix spec difference between GLSL 4.1 or lower and ESSL3", &members};
158
159     // On Intel Mac OSX 10.11 driver, using "-float" will get wrong answer. Use "0.0 - float" to
160     // replace "-float".
161     // Tracking bug: http://crbug.com/308366
162     Feature rewriteFloatUnaryMinusOperator = {
163         "rewrite_float_unary_minus_operator", FeatureCategory::OpenGLWorkarounds,
164         "Using '-<float>' will get wrong answer", &members, "http://crbug.com/308366"};
165
166     // On NVIDIA drivers, atan(y, x) may return a wrong answer.
167     // Tracking bug: http://crbug.com/672380
168     Feature emulateAtan2Float = {"emulate_atan_2_float", FeatureCategory::OpenGLWorkarounds,
169                                  "atan(y, x) may return a wrong answer", &members,
170                                  "http://crbug.com/672380"};
171
172     // Some drivers seem to forget about UBO bindings when using program binaries. Work around
173     // this by re-applying the bindings after the program binary is loaded or saved.
174     // This only seems to affect AMD OpenGL drivers, and some Android devices.
175     // http://anglebug.com/1637
176     Feature reapplyUBOBindingsAfterUsingBinaryProgram = {
177         "reapply_ubo_bindings_after_using_binary_program", FeatureCategory::OpenGLWorkarounds,
178         "Some drivers forget about UBO bindings when using program binaries", &members,
179         "http://anglebug.com/1637"};
180
181     // Some Linux OpenGL drivers return 0 when we query MAX_VERTEX_ATTRIB_STRIDE in an OpenGL 4.4 or
182     // higher context.
183     // This only seems to affect AMD OpenGL drivers.
184     // Tracking bug: http://anglebug.com/1936
185     Feature emulateMaxVertexAttribStride = {
186         "emulate_max_vertex_attrib_stride", FeatureCategory::OpenGLWorkarounds,
187         "Some drivers return 0 when MAX_VERTEX_ATTRIB_STRIED queried", &members,
188         "http://anglebug.com/1936"};
189
190     // Initializing uninitialized locals caused odd behavior on Android Qualcomm in a few WebGL 2
191     // tests. Tracking bug: http://anglebug.com/2046
192     Feature dontInitializeUninitializedLocals = {
193         "dont_initialize_uninitialized_locals", FeatureCategory::OpenGLWorkarounds,
194         "Initializing uninitialized locals caused odd behavior in a few WebGL 2 tests", &members,
195         "http://anglebug.com/2046"};
196
197     // On some NVIDIA drivers the point size range reported from the API is inconsistent with the
198     // actual behavior. Clamp the point size to the value from the API to fix this.
199     Feature clampPointSize = {
200         "clamp_point_size", FeatureCategory::OpenGLWorkarounds,
201         "The point size range reported from the API is inconsistent with the actual behavior",
202         &members};
203
204     // On some NVIDIA drivers certain types of GLSL arithmetic ops mixing vectors and scalars may be
205     // executed incorrectly. Change them in the shader translator. Tracking bug:
206     // http://crbug.com/772651
207     Feature rewriteVectorScalarArithmetic = {"rewrite_vector_scalar_arithmetic",
208                                              FeatureCategory::OpenGLWorkarounds,
209                                              "Certain types of GLSL arithmetic ops mixing vectors "
210                                              "and scalars may be executed incorrectly",
211                                              &members, "http://crbug.com/772651"};
212
213     // On some Android devices for loops used to initialize variables hit native GLSL compiler bugs.
214     Feature dontUseLoopsToInitializeVariables = {
215         "dont_use_loops_to_initialize_variables", FeatureCategory::OpenGLWorkarounds,
216         "For loops used to initialize variables hit native GLSL compiler bugs", &members,
217         "http://crbug.com/809422"};
218
219     // On some NVIDIA drivers gl_FragDepth is not clamped correctly when rendering to a floating
220     // point depth buffer. Clamp it in the translated shader to fix this.
221     Feature clampFragDepth = {
222         "clamp_frag_depth", FeatureCategory::OpenGLWorkarounds,
223         "gl_FragDepth is not clamped correctly when rendering to a floating point depth buffer",
224         &members};
225
226     // On some NVIDIA drivers before version 397.31 repeated assignment to swizzled values inside a
227     // GLSL user-defined function have incorrect results. Rewrite this type of statements to fix
228     // this.
229     Feature rewriteRepeatedAssignToSwizzled = {"rewrite_repeated_assign_to_swizzled",
230                                                FeatureCategory::OpenGLWorkarounds,
231                                                "Repeated assignment to swizzled values inside a "
232                                                "GLSL user-defined function have incorrect results",
233                                                &members};
234
235     // On some AMD and Intel GL drivers ARB_blend_func_extended does not pass the tests.
236     // It might be possible to work around the Intel bug by rewriting *FragData to *FragColor
237     // instead of disabling the functionality entirely. The AMD bug looked like incorrect blending,
238     // not sure if a workaround is feasible. http://anglebug.com/1085
239     Feature disableBlendFuncExtended = {
240         "disable_blend_func_extended", FeatureCategory::OpenGLWorkarounds,
241         "ARB_blend_func_extended does not pass the tests", &members, "http://anglebug.com/1085"};
242
243     // Qualcomm drivers returns raw sRGB values instead of linearized values when calling
244     // glReadPixels on unsized sRGB texture formats. http://crbug.com/550292 and
245     // http://crbug.com/565179
246     Feature unsizedsRGBReadPixelsDoesntTransform = {
247         "unsized_srgb_read_pixels_doesnt_transform", FeatureCategory::OpenGLWorkarounds,
248         "Drivers returning raw sRGB values instead of linearized values when calling glReadPixels "
249         "on unsized sRGB texture formats",
250         &members, "http://crbug.com/565179"};
251
252     // Older Qualcomm drivers generate errors when querying the number of bits in timer queries, ex:
253     // GetQueryivEXT(GL_TIME_ELAPSED, GL_QUERY_COUNTER_BITS).  http://anglebug.com/3027
254     Feature queryCounterBitsGeneratesErrors = {
255         "query_counter_bits_generates_errors", FeatureCategory::OpenGLWorkarounds,
256         "Drivers generate errors when querying the number of bits in timer queries", &members,
257         "http://anglebug.com/3027"};
258
259     // Re-linking a program in parallel is buggy on some Intel Windows OpenGL drivers and Android
260     // platforms.
261     // http://anglebug.com/3045
262     Feature dontRelinkProgramsInParallel = {
263         "dont_relink_programs_in_parallel", FeatureCategory::OpenGLWorkarounds,
264         "Relinking a program in parallel is buggy", &members, "http://anglebug.com/3045"};
265
266     // Some tests have been seen to fail using worker contexts, this switch allows worker contexts
267     // to be disabled for some platforms. http://crbug.com/849576
268     Feature disableWorkerContexts = {"disable_worker_contexts", FeatureCategory::OpenGLWorkarounds,
269                                      "Some tests have been seen to fail using worker contexts",
270                                      &members, "http://crbug.com/849576"};
271
272     // Most Android devices fail to allocate a texture that is larger than 4096. Limit the caps
273     // instead of generating GL_OUT_OF_MEMORY errors. Also causes system to hang on some older
274     // intel mesa drivers on Linux.
275     Feature limitMaxTextureSizeTo4096 = {"max_texture_size_limit_4096",
276                                          FeatureCategory::OpenGLWorkarounds,
277                                          "Limit max texture size to 4096 to avoid frequent "
278                                          "out-of-memory errors",
279                                          &members, "http://crbug.com/927470"};
280
281     // Prevent excessive MSAA allocations on Android devices, various rendering bugs have been
282     // observed and they tend to be high DPI anyways. http://crbug.com/797243
283     Feature limitMaxMSAASamplesTo4 = {
284         "max_msaa_sample_count_4", FeatureCategory::OpenGLWorkarounds,
285         "Various rendering bugs have been observed when using higher MSAA counts", &members,
286         "http://crbug.com/797243"};
287
288     // Prefer to do the robust resource init clear using a glClear. Calls to TexSubImage2D on large
289     // textures can take hundreds of milliseconds because of slow uploads on macOS. Do this only on
290     // macOS because clears are buggy on other drivers.
291     // https://crbug.com/848952 (slow uploads on macOS)
292     // https://crbug.com/883276 (buggy clears on Android)
293     Feature allowClearForRobustResourceInit = {
294         "allow_clear_for_robust_resource_init", FeatureCategory::OpenGLWorkarounds,
295         "Using glClear for robust resource initialization is buggy on some drivers and leads to "
296         "texture corruption. Default to data uploads except on MacOS where it is very slow.",
297         &members, "http://crbug.com/883276"};
298
299     // Some drivers automatically handle out-of-bounds uniform array access but others need manual
300     // clamping to satisfy the WebGL requirements.
301     Feature clampArrayAccess = {"clamp_array_access", FeatureCategory::OpenGLWorkarounds,
302                                 "Clamp uniform array access to avoid reading invalid memory.",
303                                 &members, "http://anglebug.com/2978"};
304
305     // Reset glTexImage2D base level to workaround pixel comparison failure above Mac OS 10.12.4 on
306     // Intel Mac.
307     Feature resetTexImage2DBaseLevel = {"reset_teximage2d_base_level",
308                                         FeatureCategory::OpenGLWorkarounds,
309                                         "Reset texture base level before calling glTexImage2D to "
310                                         "work around pixel comparison failure.",
311                                         &members, "https://crbug.com/705865"};
312
313     // glClearColor does not always work on Intel 6xxx Mac drivers when the clear color made up of
314     // all zeros and ones.
315     Feature clearToZeroOrOneBroken = {
316         "clear_to_zero_or_one_broken", FeatureCategory::OpenGLWorkarounds,
317         "Clears when the clear color is all zeros or ones do not work.", &members,
318         "https://crbug.com/710443"};
319
320     // Some older Linux Intel mesa drivers will hang the system when allocating large textures. Fix
321     // this by capping the max texture size.
322     Feature limitMax3dArrayTextureSizeTo1024 = {
323         "max_3d_array_texture_size_1024", FeatureCategory::OpenGLWorkarounds,
324         "Limit max 3d texture size and max array texture layers to 1024 to avoid system hang",
325         &members, "http://crbug.com/927470"};
326
327     // BlitFramebuffer has issues on some platforms with large source/dest texture sizes. This
328     // workaround adjusts the destination rectangle source and dest rectangle to fit within maximum
329     // twice the size of the framebuffer.
330     Feature adjustSrcDstRegionBlitFramebuffer = {
331         "adjust_src_dst_region_for_blitframebuffer", FeatureCategory::OpenGLWorkarounds,
332         "Many platforms have issues with blitFramebuffer when the parameters are large.", &members,
333         "http://crbug.com/830046"};
334
335     // BlitFramebuffer has issues on Mac when the source bounds aren't enclosed by the framebuffer.
336     // This workaround clips the source region and adjust the dest region proportionally.
337     Feature clipSrcRegionBlitFramebuffer = {
338         "clip_src_region_for_blitframebuffer", FeatureCategory::OpenGLWorkarounds,
339         "Issues with blitFramebuffer when the parameters don't match the framebuffer size.",
340         &members, "http://crbug.com/830046"};
341
342     // Calling glTexImage2D with zero size generates GL errors
343     Feature resettingTexturesGeneratesErrors = {
344         "reset_texture_generates_errors", FeatureCategory::OpenGLWorkarounds,
345         "Calling glTexImage2D with zero size generates errors.", &members,
346         "http://anglebug.com/3859"};
347
348     // Mac Intel samples transparent black from GL_COMPRESSED_RGB_S3TC_DXT1_EXT
349     Feature rgbDXT1TexturesSampleZeroAlpha = {
350         "rgb_dxt1_textures_sample_zero_alpha", FeatureCategory::OpenGLWorkarounds,
351         "Sampling BLACK texels from RGB DXT1 textures returns transparent black on Mac.", &members,
352         "http://anglebug.com/3729"};
353
354     // Mac incorrectly executes both sides of && and || expressions when they should short-circuit.
355     Feature unfoldShortCircuits = {
356         "unfold_short_circuits", FeatureCategory::OpenGLWorkarounds,
357         "Mac incorrectly executes both sides of && and || expressions when they should "
358         "short-circuit.",
359         &members, "http://anglebug.com/482"};
360
361     Feature emulatePrimitiveRestartFixedIndex = {
362         "emulate_primitive_restart_fixed_index", FeatureCategory::OpenGLWorkarounds,
363         "When GL_PRIMITIVE_RESTART_FIXED_INDEX is not available, emulate it with "
364         "GL_PRIMITIVE_RESTART and glPrimitiveRestartIndex.",
365         &members, "http://anglebug.com/3997"};
366
367     Feature setPrimitiveRestartFixedIndexForDrawArrays = {
368         "set_primitive_restart_fixed_index_for_draw_arrays", FeatureCategory::OpenGLWorkarounds,
369         "Some drivers discard vertex data in DrawArrays calls when the fixed primitive restart "
370         "index is within the number of primitives being drawn.",
371         &members, "http://anglebug.com/3997"};
372
373     // Dynamic indexing of swizzled l-values doesn't work correctly on various platforms.
374     Feature removeDynamicIndexingOfSwizzledVector = {
375         "remove_dynamic_indexing_of_swizzled_vector", FeatureCategory::OpenGLWorkarounds,
376         "Dynamic indexing of swizzled l-values doesn't work correctly on various platforms.",
377         &members, "http://crbug.com/709351"};
378
379     // Intel Mac drivers does not treat texelFetchOffset() correctly.
380     Feature preAddTexelFetchOffsets = {
381         "pre_add_texel_fetch_offsets", FeatureCategory::OpenGLWorkarounds,
382         "Intel Mac drivers mistakenly consider the parameter position of nagative vaule as invalid "
383         "even if the sum of position and offset is in range, so we need to add workarounds by "
384         "rewriting texelFetchOffset(sampler, position, lod, offset) into texelFetch(sampler, "
385         "position + offset, lod).",
386         &members, "http://crbug.com/642605"};
387
388     // All Mac drivers do not handle struct scopes correctly. This workaround overwrites a struct
389     // name with a unique prefix
390     Feature regenerateStructNames = {
391         "regenerate_struct_names", FeatureCategory::OpenGLWorkarounds,
392         "All Mac drivers do not handle struct scopes correctly. This workaround overwrites a struct"
393         "name with a unique prefix.",
394         &members, "http://crbug.com/403957"};
395
396     // Quite some OpenGL ES drivers don't implement readPixels for RGBA/UNSIGNED_SHORT from
397     // EXT_texture_norm16 correctly
398     Feature readPixelsUsingImplementationColorReadFormatForNorm16 = {
399         "read_pixels_using_implementation_color_read_format", FeatureCategory::OpenGLWorkarounds,
400         "Quite some OpenGL ES drivers don't implement readPixels for RGBA/UNSIGNED_SHORT from "
401         "EXT_texture_norm16 correctly",
402         &members, "http://anglebug.com/4214"};
403
404     // Bugs exist in some Intel drivers where dependencies are incorrectly
405     // tracked for textures which are copy destinations (via CopyTexImage2D, for
406     // example). Flush before DeleteTexture if these entry points have been
407     // called recently.
408     Feature flushBeforeDeleteTextureIfCopiedTo = {
409         "flush_before_delete_texture_if_copied_to", FeatureCategory::OpenGLWorkarounds,
410         "Some drivers track CopyTex{Sub}Image texture dependencies incorrectly. Flush"
411         " before glDeleteTextures in this case",
412         &members, "http://anglebug.com/4267"};
413
414     // Rewrite row-major matrices as column-major as a driver bug workaround if
415     // necessary.
416     Feature rewriteRowMajorMatrices = {
417         "rewrite_row_major_matrices", FeatureCategory::OpenGLWorkarounds,
418         "Rewrite row major matrices in shaders as column major as a driver bug workaround",
419         &members, "http://anglebug.com/2273"};
420
421     // Flush before glBindFramebuffer as a driver bug workaround if necessary.
422     Feature flushBeforeBindFramebuffer = {
423         "flush_before_bindframebuffer", FeatureCategory::OpenGLWorkarounds,
424         "Flush before glBindFramebuffer as a driver bug workaround",
425         &members, "https://bugs.webkit.org/show_bug.cgi?id=206625"};
426
427     // Bugs exist in various OpenGL Intel drivers on Windows that produce incorrect
428     // values for GL_COMPRESSED_SRGB_S3TC_DXT1_EXT format. Replace it with
429     // GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT as it's the closest option allowed by
430     // the WebGL extension spec.
431     Feature avoidDXT1sRGBTextureFormat = {
432         "avoid_dxt1_srgb_texture_format", FeatureCategory::OpenGLWorkarounds,
433         "Replaces DXT1 sRGB with DXT1 sRGB Alpha as a driver bug workaround.", &members};
434
435     // Bugs exist in OpenGL AMD drivers on Windows that produce incorrect pipeline state for
436     // colorMaski calls.
437     Feature disableDrawBuffersIndexed = {"disable_draw_buffers_indexed",
438                                          FeatureCategory::OpenGLWorkarounds,
439                                          "Disable OES_draw_buffers_indexed extension.", &members};
440
441     // GL_EXT_semaphore_fd doesn't work properly with Mesa 19.3.4 and earlier versions.
442     Feature disableSemaphoreFd = {"disable_semaphore_fd", FeatureCategory::OpenGLWorkarounds,
443                                   "Disable GL_EXT_semaphore_fd extension", &members,
444                                   "https://crbug.com/1046462"};
445 };
446
447 inline FeaturesGL::FeaturesGL()  = default;
448 inline FeaturesGL::~FeaturesGL() = default;
449
450 }  // namespace angle
451
452 #endif  // ANGLE_PLATFORM_FEATURESGL_H_