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 // Bugs exist in various OpenGL Intel drivers on Windows that produce incorrect 422 // values for GL_COMPRESSED_SRGB_S3TC_DXT1_EXT format. Replace it with 423 // GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT as it's the closest option allowed by 424 // the WebGL extension spec. 425 Feature avoidDXT1sRGBTextureFormat = { 426 "avoid_dxt1_srgb_texture_format", FeatureCategory::OpenGLWorkarounds, 427 "Replaces DXT1 sRGB with DXT1 sRGB Alpha as a driver bug workaround.", &members}; 428 429 // GL_EXT_semaphore_fd doesn't work properly with Mesa 19.3.4 and earlier versions. 430 Feature disableSemaphoreFd = {"disable_semaphore_fd", FeatureCategory::OpenGLWorkarounds, 431 "Disable GL_EXT_semaphore_fd extension", &members, 432 "https://crbug.com/1046462"}; 433 }; 434 435 inline FeaturesGL::FeaturesGL() = default; 436 inline FeaturesGL::~FeaturesGL() = default; 437 438 } // namespace angle 439 440 #endif // ANGLE_PLATFORM_FEATURESGL_H_ 441