gfx/gl/GLContextFeatures.cpp

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6
   7 #include "GLContext.h"
   8 #include "nsPrintfCString.h"
   9
  10 #ifdef XP_MACOSX
  11 #include "nsCocoaFeatures.h"
  12 #endif
  13
  14 namespace mozilla {
  15 namespace gl {
  16
  17 const size_t kMAX_EXTENSION_GROUP_SIZE = 5;
  18
  19 // ARB_ES2_compatibility is natively supported in OpenGL 4.1.
  20 static const unsigned int kGLCoreVersionForES2Compat = 410;
  21
  22 // ARB_ES3_compatibility is natively supported in OpenGL 4.3.
  23 static const unsigned int kGLCoreVersionForES3Compat = 430;
  24
  25 struct FeatureInfo
  26 {
  27     const char* mName;
  28
  29     /* The (desktop) OpenGL version that provides this feature */
  30     unsigned int mOpenGLVersion;
  31
  32     /* The OpenGL ES version that provides this feature */
  33     unsigned int mOpenGLESVersion;
  34
  35     /* If there is an ARB extension, and its function symbols are
  36      * not decorated with an ARB suffix, then its extension ID should go
  37      * here, and NOT in mExtensions.  For example, ARB_vertex_array_object
  38      * functions do not have an ARB suffix, because it is an extension that
  39      * was created to match core GL functionality and will never differ.
  40      * Some ARB extensions do have a suffix, if they were created before
  41      * a core version of the functionality existed.
  42      *
  43      * If there is no such ARB extension, pass 0 (GLContext::Extension_None)
  44      */
  45     GLContext::GLExtensions mARBExtensionWithoutARBSuffix;
  46
  47     /* Extensions that also provide this feature */
  48     GLContext::GLExtensions mExtensions[kMAX_EXTENSION_GROUP_SIZE];
  49 };
  50
  51 static const FeatureInfo sFeatureInfoArr[] = {
  52     {
  53         "bind_buffer_offset",
  54         0,   // OpenGL version
  55         0,   // OpenGL ES version
  56         GLContext::Extension_None,
  57         {
  58
  59             GLContext::EXT_transform_feedback,
  60             GLContext::NV_transform_feedback,
  61             GLContext::Extensions_End
  62         }
  63     },
  64     {
  65         "blend_minmax",
  66         200, // OpenGL version
  67         300, // OpenGL ES version
  68         GLContext::Extension_None,
  69         {
  70             GLContext::EXT_blend_minmax,
  71             GLContext::Extensions_End
  72         }
  73     },
  74     {
  75         "depth_texture",
  76         200, // OpenGL version
  77         300, // OpenGL ES version
  78         GLContext::Extension_None,
  79         {
  80             GLContext::ARB_depth_texture,
  81             GLContext::OES_depth_texture,
  82             // Intentionally avoid putting ANGLE_depth_texture here,
  83             // it does not offer quite the same functionality.
  84             GLContext::Extensions_End
  85         }
  86     },
  87     {
  88         "draw_buffers",
  89         200, // OpenGL version
  90         300, // OpenGL ES version
  91         GLContext::Extension_None,
  92         {
  93             GLContext::ARB_draw_buffers,
  94             GLContext::EXT_draw_buffers,
  95             GLContext::Extensions_End
  96         }
  97     },
  98     {
  99         "draw_instanced",
 100         310, // OpenGL version
 101         300, // OpenGL ES version
 102         GLContext::Extension_None,
 103         {
 104             GLContext::ARB_draw_instanced,
 105             GLContext::EXT_draw_instanced,
 106             GLContext::NV_draw_instanced,
 107             GLContext::ANGLE_instanced_arrays,
 108             GLContext::Extensions_End
 109         }
 110     },
 111     {
 112         "draw_range_elements",
 113         120, // OpenGL version
 114         300, // OpenGL ES version
 115         GLContext::Extension_None,
 116         {
 117             GLContext::EXT_draw_range_elements,
 118             GLContext::Extensions_End
 119         }
 120     },
 121     {
 122         "element_index_uint",
 123         200, // OpenGL version
 124         300, // OpenGL ES version
 125         GLContext::Extension_None,
 126         {
 127             GLContext::OES_element_index_uint,
 128             GLContext::Extensions_End
 129         }
 130     },
 131     {
 132         "ES2_compatibility",
 133         kGLCoreVersionForES2Compat,
 134         200, // OpenGL ES version
 135         GLContext::ARB_ES2_compatibility, // no suffix on ARB extension
 136         {
 137             GLContext::Extensions_End
 138         }
 139     },
 140     {
 141         "ES3_compatibility",
 142         kGLCoreVersionForES3Compat,
 143         300, // OpenGL ES version
 144         GLContext::ARB_ES3_compatibility, // no suffix on ARB extension
 145         {
 146             GLContext::Extensions_End
 147         }
 148     },
 149     {
 150         // Removes clamping for float color outputs from frag shaders.
 151         "frag_color_float",
 152         300, // OpenGL version
 153         300, // OpenGL ES version
 154         GLContext::Extension_None,
 155         {
 156             GLContext::ARB_color_buffer_float,
 157             GLContext::EXT_color_buffer_float,
 158             GLContext::EXT_color_buffer_half_float,
 159             GLContext::Extensions_End
 160         }
 161     },
 162     {
 163         "frag_depth",
 164         200, // OpenGL version
 165         300, // OpenGL ES version
 166         GLContext::Extension_None,
 167         {
 168             GLContext::EXT_frag_depth,
 169             GLContext::Extensions_End
 170         }
 171     },
 172     {
 173         "framebuffer_blit",
 174         300, // OpenGL version
 175         300, // OpenGL ES version
 176         GLContext::Extension_None,
 177         {
 178             GLContext::EXT_framebuffer_blit,
 179             GLContext::ANGLE_framebuffer_blit,
 180             GLContext::Extensions_End
 181         }
 182     },
 183     {
 184         "framebuffer_multisample",
 185         300, // OpenGL version
 186         300, // OpenGL ES version
 187         GLContext::Extension_None,
 188         {
 189             GLContext::EXT_framebuffer_multisample,
 190             GLContext::ANGLE_framebuffer_multisample,
 191             GLContext::Extensions_End
 192         }
 193     },
 194     {
 195         "framebuffer_object",
 196         300, // OpenGL version
 197         200, // OpenGL ES version
 198         GLContext::ARB_framebuffer_object,
 199         {
 200             GLContext::EXT_framebuffer_object,
 201             GLContext::Extensions_End
 202         }
 203     },
 204     {
 205         "get_query_object_iv",
 206         200, // OpenGL version
 207         0,   // OpenGL ES version
 208         GLContext::Extension_None,
 209         {
 210             GLContext::Extensions_End
 211         }
 212         /*
 213          * XXX_get_query_object_iv only provide GetQueryObjectiv provided by
 214          * ARB_occlusion_query (added by OpenGL 2.0).
 215          */
 216     },
 217     {
 218         "instanced_arrays",
 219         330, // OpenGL version
 220         300, // OpenGL ES version
 221         GLContext::Extension_None,
 222         {
 223             GLContext::ARB_instanced_arrays,
 224             GLContext::NV_instanced_arrays,
 225             GLContext::ANGLE_instanced_arrays,
 226             GLContext::Extensions_End
 227         }
 228     },
 229     {
 230         "instanced_non_arrays",
 231         330, // OpenGL version
 232         300, // OpenGL ES version
 233         GLContext::Extension_None,
 234         {
 235             GLContext::ARB_instanced_arrays,
 236             GLContext::Extensions_End
 237         }
 238         /* This is an expanded version of `instanced_arrays` that allows for all
 239          * enabled active attrib arrays to have non-zero divisors.
 240          * ANGLE_instanced_arrays and NV_instanced_arrays forbid this, but GLES3
 241          * has no such restriction.
 242          */
 243     },
 244     {
 245         "occlusion_query",
 246         200, // OpenGL version
 247         0,   // OpenGL ES version
 248         GLContext::Extension_None,
 249         {
 250             GLContext::Extensions_End
 251         }
 252         // XXX_occlusion_query depend on ARB_occlusion_query (added in OpenGL 2.0)
 253     },
 254     {
 255         "occlusion_query_boolean",
 256         kGLCoreVersionForES3Compat,
 257         300, // OpenGL ES version
 258         GLContext::ARB_ES3_compatibility,
 259         {
 260             GLContext::EXT_occlusion_query_boolean,
 261             GLContext::Extensions_End
 262         }
 263         /*
 264          * XXX_occlusion_query_boolean provide ANY_SAMPLES_PASSED_CONSERVATIVE,
 265          * but EXT_occlusion_query_boolean is only a OpenGL ES extension. But
 266          * it is supported on desktop if ARB_ES3_compatibility because
 267          * EXT_occlusion_query_boolean (added in OpenGL ES 3.0).
 268          */
 269     },
 270     {
 271         "occlusion_query2",
 272         330, // = min(330, kGLCoreVersionForES3Compat),
 273         300, // OpenGL ES version
 274         GLContext::Extension_None,
 275         {
 276             GLContext::ARB_occlusion_query2,
 277             GLContext::ARB_ES3_compatibility,
 278             GLContext::EXT_occlusion_query_boolean,
 279             GLContext::Extensions_End
 280         }
 281         /*
 282          * XXX_occlusion_query2 (add in OpenGL 3.3) provide ANY_SAMPLES_PASSED,
 283          * which is provided by ARB_occlusion_query2, EXT_occlusion_query_boolean
 284          * (added in OpenGL ES 3.0) and ARB_ES3_compatibility
 285          */
 286     },
 287     {
 288         "packed_depth_stencil",
 289         300, // OpenGL version
 290         300, // OpenGL ES version
 291         GLContext::Extension_None,
 292         {
 293             GLContext::EXT_packed_depth_stencil,
 294             GLContext::OES_packed_depth_stencil,
 295             GLContext::Extensions_End
 296         }
 297     },
 298     {
 299         "query_objects",
 300         200, // OpenGL version
 301         300, // OpenGL ES version
 302         GLContext::Extension_None,
 303         {
 304             GLContext::EXT_occlusion_query_boolean,
 305             GLContext::Extensions_End
 306         }
 307         /*
 308          * XXX_query_objects only provide entry points commonly supported by
 309          * ARB_occlusion_query (added in OpenGL 2.0) and EXT_occlusion_query_boolean
 310          * (added in OpenGL ES 3.0)
 311          */
 312     },
 313     {
 314         "renderbuffer_float",
 315         300, // OpenGL version
 316         300, // OpenGL ES version
 317         GLContext::Extension_None,
 318         {
 319             GLContext::ARB_texture_float,
 320             GLContext::EXT_color_buffer_float,
 321             GLContext::Extensions_End
 322         }
 323     },
 324     {
 325         "renderbuffer_half_float",
 326         300, // OpenGL version
 327         300, // OpenGL ES version
 328         GLContext::Extension_None,
 329         {
 330             GLContext::ARB_texture_float,
 331             GLContext::EXT_color_buffer_half_float,
 332             GLContext::Extensions_End
 333         }
 334     },
 335     {
 336         "robustness",
 337         0,   // OpenGL version
 338         0,   // OpenGL ES version
 339         GLContext::Extension_None,
 340         {
 341             GLContext::ARB_robustness,
 342             GLContext::EXT_robustness,
 343             GLContext::Extensions_End
 344         }
 345     },
 346     {
 347         "sRGB",
 348         300, // OpenGL version
 349         300, // OpenGL ES version
 350         GLContext::Extension_None,
 351         {
 352             GLContext::EXT_sRGB,
 353             GLContext::Extensions_End
 354         }
 355     },
 356     {
 357         "standard_derivatives",
 358         200, // OpenGL version
 359         300, // OpenGL ES version
 360         GLContext::Extension_None,
 361         {
 362             GLContext::OES_standard_derivatives,
 363             GLContext::Extensions_End
 364         }
 365     },
 366     {
 367         "texture_float",
 368         300, // OpenGL version
 369         300, // OpenGL ES version
 370         GLContext::Extension_None,
 371         {
 372             GLContext::ARB_texture_float,
 373             GLContext::OES_texture_float,
 374             GLContext::Extensions_End
 375         }
 376     },
 377     {
 378         "texture_float_linear",
 379         310, // OpenGL version
 380         300, // OpenGL ES version
 381         GLContext::Extension_None,
 382         {
 383             GLContext::ARB_texture_float,
 384             GLContext::OES_texture_float_linear,
 385             GLContext::Extensions_End
 386         }
 387     },
 388     {
 389         "texture_half_float",
 390         300, // OpenGL version
 391         300, // OpenGL ES version
 392         GLContext::Extension_None,
 393         {
 394             GLContext::ARB_half_float_pixel,
 395             GLContext::ARB_texture_float,
 396             GLContext::NV_half_float,
 397             GLContext::Extensions_End
 398         }
 399         /**
 400          * We are not including OES_texture_half_float in this feature, because:
 401          *   GL_HALF_FLOAT     = 0x140B
 402          *   GL_HALF_FLOAT_ARB = 0x140B == GL_HALF_FLOAT
 403          *   GL_HALF_FLOAT_NV  = 0x140B == GL_HALF_FLOAT
 404          *   GL_HALF_FLOAT_OES = 0x8D61 != GL_HALF_FLOAT
 405          * WebGL handles this specifically with an OES_texture_half_float check.
 406          */
 407     },
 408     {
 409         "texture_half_float_linear",
 410         310, // OpenGL version
 411         300, // OpenGL ES version
 412         GLContext::Extension_None,
 413         {
 414             GLContext::ARB_half_float_pixel,
 415             GLContext::ARB_texture_float,
 416             GLContext::NV_half_float,
 417             GLContext::OES_texture_half_float_linear,
 418             GLContext::Extensions_End
 419         }
 420     },
 421     {
 422         "texture_non_power_of_two",
 423         200, // OpenGL version
 424         300, // OpenGL ES version
 425         GLContext::Extension_None,
 426         {
 427             GLContext::ARB_texture_non_power_of_two,
 428             GLContext::OES_texture_npot,
 429             GLContext::Extensions_End
 430         }
 431     },
 432     {
 433         "transform_feedback",
 434         300, // OpenGL version
 435         300, // OpenGL ES version
 436         GLContext::Extension_None,
 437         {
 438             GLContext::EXT_transform_feedback,
 439             GLContext::NV_transform_feedback,
 440             GLContext::Extensions_End
 441         }
 442     },
 443     {
 444         "vertex_array_object",
 445         300, // OpenGL version
 446         300, // OpenGL ES version
 447         GLContext::ARB_vertex_array_object, // ARB extension
 448         {
 449             GLContext::OES_vertex_array_object,
 450             GLContext::APPLE_vertex_array_object,
 451             GLContext::Extensions_End
 452         }
 453     }
 454 };
 455
 456 static inline const FeatureInfo&
 457 GetFeatureInfo(GLFeature feature)
 458 {
 459     static_assert(MOZ_ARRAY_LENGTH(sFeatureInfoArr) == size_t(GLFeature::EnumMax),
 460                   "Mismatched lengths for sFeatureInfoInfos and GLFeature enums");
 461
 462     MOZ_ASSERT(feature < GLFeature::EnumMax,
 463                "GLContext::GetFeatureInfoInfo : unknown <feature>");
 464
 465     return sFeatureInfoArr[size_t(feature)];
 466 }
 467
 468 static inline uint32_t
 469 ProfileVersionForFeature(GLFeature feature, ContextProfile profile)
 470 {
 471     MOZ_ASSERT(profile != ContextProfile::Unknown,
 472                "GLContext::ProfileVersionForFeature : unknown <profile>");
 473
 474     const FeatureInfo& featureInfo = GetFeatureInfo(feature);
 475
 476     if (profile == ContextProfile::OpenGLES) {
 477         return featureInfo.mOpenGLESVersion;
 478     }
 479
 480     return featureInfo.mOpenGLVersion;
 481 }
 482
 483 bool
 484 IsFeaturePartOfProfileVersion(GLFeature feature,
 485                               ContextProfile profile, unsigned int version)
 486 {
 487     unsigned int profileVersion = ProfileVersionForFeature(feature, profile);
 488
 489     /**
 490      * if `profileVersion` is zero, it means that no version of the profile
 491      * added support for the feature.
 492      */
 493     return profileVersion && version >= profileVersion;
 494 }
 495
 496 bool
 497 GLContext::IsFeatureProvidedByCoreSymbols(GLFeature feature)
 498 {
 499     if (IsFeaturePartOfProfileVersion(feature, mProfile, mVersion))
 500         return true;
 501
 502     if (IsExtensionSupported(GetFeatureInfo(feature).mARBExtensionWithoutARBSuffix))
 503         return true;
 504
 505     return false;
 506 }
 507
 508 const char*
 509 GLContext::GetFeatureName(GLFeature feature)
 510 {
 511     return GetFeatureInfo(feature).mName;
 512 }
 513
 514 static bool
 515 CanReadSRGBFromFBOTexture(GLContext* gl)
 516 {
 517     if (!gl->WorkAroundDriverBugs())
 518         return true;
 519
 520 #ifdef XP_MACOSX
 521     // Bug 843668:
 522     // MacOSX 10.6 reports to support EXT_framebuffer_sRGB and
 523     // EXT_texture_sRGB but fails to convert from sRGB to linear
 524     // when writing to an sRGB texture attached to an FBO.
 525     if (!nsCocoaFeatures::OnLionOrLater()) {
 526         return false;
 527     }
 528 #endif // XP_MACOSX
 529     return true;
 530 }
 531
 532 void
 533 GLContext::InitFeatures()
 534 {
 535     for (size_t feature_index = 0; feature_index < size_t(GLFeature::EnumMax); feature_index++)
 536     {
 537         GLFeature feature = GLFeature(feature_index);
 538
 539         if (IsFeaturePartOfProfileVersion(feature, mProfile, mVersion)) {
 540             mAvailableFeatures[feature_index] = true;
 541             continue;
 542         }
 543
 544         mAvailableFeatures[feature_index] = false;
 545
 546         const FeatureInfo& featureInfo = GetFeatureInfo(feature);
 547
 548         if (IsExtensionSupported(featureInfo.mARBExtensionWithoutARBSuffix))
 549         {
 550             mAvailableFeatures[feature_index] = true;
 551             continue;
 552         }
 553
 554         for (size_t j = 0; true; j++)
 555         {
 556             MOZ_ASSERT(j < kMAX_EXTENSION_GROUP_SIZE, "kMAX_EXTENSION_GROUP_SIZE too small");
 557
 558             if (featureInfo.mExtensions[j] == GLContext::Extensions_End) {
 559                 break;
 560             }
 561
 562             if (IsExtensionSupported(featureInfo.mExtensions[j])) {
 563                 mAvailableFeatures[feature_index] = true;
 564                 break;
 565             }
 566         }
 567     }
 568
 569     // Bug 843668: Work around limitation of the feature system.
 570     // For sRGB support under OpenGL to match OpenGL ES spec, check for both
 571     // EXT_texture_sRGB and EXT_framebuffer_sRGB is required.
 572     const bool aresRGBExtensionsAvailable =
 573         IsExtensionSupported(EXT_texture_sRGB) &&
 574         (IsExtensionSupported(ARB_framebuffer_sRGB) ||
 575          IsExtensionSupported(EXT_framebuffer_sRGB));
 576
 577     mAvailableFeatures[size_t(GLFeature::sRGB)] =
 578         aresRGBExtensionsAvailable &&
 579         CanReadSRGBFromFBOTexture(this);
 580 }
 581
 582 void
 583 GLContext::MarkUnsupported(GLFeature feature)
 584 {
 585     mAvailableFeatures[size_t(feature)] = false;
 586
 587     const FeatureInfo& featureInfo = GetFeatureInfo(feature);
 588
 589     for (size_t i = 0; true; i++)
 590     {
 591         MOZ_ASSERT(i < kMAX_EXTENSION_GROUP_SIZE, "kMAX_EXTENSION_GROUP_SIZE too small");
 592
 593         if (featureInfo.mExtensions[i] == GLContext::Extensions_End) {
 594             break;
 595         }
 596
 597         MarkExtensionUnsupported(featureInfo.mExtensions[i]);
 598     }
 599
 600     MOZ_ASSERT(!IsSupported(feature), "GLContext::MarkUnsupported has failed!");
 601
 602     NS_WARNING(nsPrintfCString("%s marked as unsupported", GetFeatureName(feature)).get());
 603 }
 604
 605 } /* namespace gl */
 606 } /* namespace mozilla */