1Name 2 3 KHR_create_context 4 5Name Strings 6 7 EGL_KHR_create_context 8 9Contact 10 11 Jon Leech (jon 'at' alumni.caltech.edu) 12 13Notice 14 15 Copyright (c) 2010-2013 The Khronos Group Inc. Copyright terms at 16 http://www.khronos.org/registry/speccopyright.html 17 18IP Status 19 20 No known IP claims. 21 22Status 23 24 Approved by the Khronos Board of Promoters on February 3, 2012 25 Updated in version 14 to add ES3 context creation bit - see Issue 8 26 27Version 28 29 Version 16, 2015/01/15 30 31Number 32 33 EGL Extension #39 34 35Dependencies 36 37 EGL 1.4 is required. 38 39 Some of the capabilities of these extensions are only available when 40 OpenGL and OpenGL ES contexts supporting specific versions, specific 41 profiles, or specific extensions can be created. All such restrictions 42 are documented in the body of this extension specification. 43 44Overview 45 46 With the advent of new versions of OpenGL which deprecate features 47 and/or break backward compatibility with older versions, there is a need 48 and desire to indicate at context creation which interface will be used. 49 This extension adds a new context creation routine with attributes 50 specifying the OpenGL version, context properties, and profile requested 51 for the context. It also allows making an OpenGL 3.0 or later context 52 (or other client API context supporting the ability) current without 53 providing a default framebuffer. The new context creation attributes 54 are also defined to work for OpenGL ES context creation when that 55 makes sense, and the extension has been augmented to allow configs to 56 advertise support for creating OpenGL ES 3.0 contexts. 57 58 59New Procedures and Functions 60 61 None. 62 63New Tokens 64 65 Accepted as an attribute name in the <*attrib_list> argument of 66 eglCreateContext: 67 68 EGL_CONTEXT_MAJOR_VERSION_KHR 0x3098 69 (this token is an alias for EGL_CONTEXT_CLIENT_VERSION) 70 EGL_CONTEXT_MINOR_VERSION_KHR 0x30FB 71 EGL_CONTEXT_FLAGS_KHR 0x30FC 72 EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 0x30FD 73 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 0x31BD 74 75 Accepted as a bitfield value in the EGL_RENDERABLE_TYPE config 76 attribute to eglChooseConfig: 77 78 EGL_OPENGL_ES3_BIT_KHR 0x0040 79 80 Accepted as attribute values for 81 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR: 82 83 EGL_NO_RESET_NOTIFICATION_KHR 0x31BE 84 EGL_LOSE_CONTEXT_ON_RESET_KHR 0x31BF 85 86 Accepted as bits in the attribute value for EGL_CONTEXT_FLAGS_KHR in 87 <*attrib_list>: 88 89 EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR 0x00000001 90 EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR 0x00000002 91 EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR 0x00000004 92 93 Accepted as bits in the attribute value for 94 EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR in <*attrib_list>: 95 96 EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR 0x00000001 97 EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002 98 99Additions to the OpenGL / WGL / GLX Specifications 100 101 None. This specification is written for EGL. 102 103Additions to the EGL 1.4 Specification 104 105 Add to table 3.3 "Types of client APIs supported by an EGLConfig" 106 107 "EGL Token Name Client API and Version Supported 108 ---------------------- -------------------------------- 109 EGL_OPENGL_ES3_BIT_KHR OpenGL ES 3.x" 110 111 Modify the last sentence of section 3.5.2 "Creating Off-Screen 112 Rendering Surfaces" 113 114 "Finally, an EGL_BAD_ATTRIBUTE error is generated if ... <config> does 115 not support OpenGL ES rendering (e.g. the EGL_RENDERABLE_TYPE 116 attribute does not include at least one of EGL_OPENGL_ES_BIT, 117 EGL_OPENGL_ES2_BIT, or EGL_OPENGL_ES3_BIT_KHR." 118 119 Modify section 3.7 "Rendering Contexts" in the paragraph near 120 the top of page 42: 121 122 "Only one OpenGL or OpenGL ES context may be current to a particular 123 thread, even if the implementation supports OpenGL and one or more 124 versions of OpenGL ES in the same runtime [fn12]." 125 126 Replace section 3.7.1 "Creating Rendering Contexts" from the 127 sixth paragraph through the end of the subsection with: 128 129 "<attrib_list> specifies a list of attributes for the context. The 130 list has the same structure as described for eglChooseConfig. If an 131 attribute is not specified in <attrib_list>, then the default value 132 specified below is used instead. Most attributes are only meaningful 133 for specific client APIs, and will generate an error when specified 134 to create for another client API context. 135 136 OpenGL and OpenGL ES Context Versions 137 ------------------------------------- 138 139 The values for attributes EGL_CONTEXT_MAJOR_VERSION_KHR and 140 EGL_CONTEXT_MINOR_VERSION_KHR specify the requested client API 141 version. They are only meaningful for OpenGL and OpenGL ES contexts, 142 and specifying them for other types of contexts will generate an 143 error. 144 145 When the current rendering API is EGL_OPENGL_ES_API or 146 EGL_OPENGL_API, the values of EGL_CONTEXT_MAJOR_VERSION_KHR (the 147 <major version> and EGL_CONTEXT_MINOR_VERSION_KHR (the <minor 148 version>) request creation of an OpenGL ES or OpenGL context, 149 respectively, supporting the specified version (<major>.<minor>) of 150 that client API. 151 [fn: the EGL 1.4 token EGL_CONTEXT_CLIENT_VERSION is an alias for 152 EGL_CONTEXT_MAJOR_VERSION_KHR, and the tokens may be used 153 interchangeably.] 154 If successful, the context returned must be <backwards compatible> 155 with the requested version. Backwards compatibility is determined as 156 follows: 157 158 If the current rendering API is EGL_OPENGL_ES_API, then: 159 160 * If version 1.0 is requested, the context returned may implement 161 either OpenGL ES 1.0 or OpenGL ES 1.1. 162 163 * If version 1.1 is requested, the context returned must implement 164 OpenGL ES 1.1. 165 166 * If version 2.0, version 3.0, or a later version (when later 167 versions are defined by Khronos) is requested, the context 168 returned must implement the requested OpenGL ES version, or any 169 later version which is backwards compatible with the requested 170 version. 171 172 If the current rendering API is EGL_OPENGL_API, then: 173 174 * If a version less than or equal to OpenGL 3.0 is requested, the 175 context returned may implement any of the following versions: 176 177 * Any version no less than that requested and no greater than 178 3.0. 179 * Version 3.1, if the GL_ARB_compatibility extension is also 180 implemented. 181 * The compatibility profile of version 3.2 or greater. 182 183 * If OpenGL 3.1 is requested, the context returned may implement 184 any of the following versions: 185 186 * Version 3.1. The GL_ARB_compatibility extension may or may 187 not be implemented, as determined by the implementation. 188 * The core profile of version 3.2 or greater. 189 190 * If OpenGL 3.2 or greater is requested, the context returned may 191 implement any of the following versions: 192 193 * The requested profile (see 194 EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR below) of the requested 195 version. 196 * The requested profile of any later version, so long as no 197 features have been removed from that later version and 198 profile. 199 200 Typically, the implementation will return the most recent version of 201 OpenGL it supports which is backwards compatible with the requested 202 version. 203 204 Querying the GL_VERSION string with glGetString in either OpenGL or 205 OpenGL ES (or the GL_MAJOR_VERSION and GL_MINOR_VERSION values with 206 glGetIntegerv, in an OpenGL 3.0 or later context) will return the 207 actual version supported by a context. 208 209 The default values for EGL_CONTEXT_MAJOR_VERSION_KHR and 210 EGL_CONTEXT_MINOR_VERSION_KHR are 1 and 0 respectively. 211 212 OpenGL Context Profiles 213 ----------------------- 214 215 The value for attribute EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR 216 specifies a <profile> of the OpenGL API. This attribute is only 217 meaningful for OpenGL contexts, and specifying it for other types of 218 contexts, including OpenGL ES contexts, will generate an error. 219 220 When the current rendering API is EGL_OPENGL_API, the value of 221 EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR requests an OpenGL context 222 supporting the corresponding profile. If the 223 EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR bit is set in the attribute 224 value, then a context implementing the <core> profile of OpenGL is 225 returned. If the EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 226 bit is set, then a context implementing the <compatibility> profile 227 is returned. If the requested OpenGL version is less than 3.2, 228 EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR is ignored and the functionality 229 of the context is determined solely by the requested version. 230 231 Querying the value of GL_CONTEXT_PROFILE_MASK with glGetIntegerv 232 will return the profile mask used to create the context. This query 233 is only supported in an OpenGL 3.2 or later context. 234 235 The default value for EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR is 236 EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR. All OpenGL 3.2 and later 237 implementations are required to implement the core profile, but 238 implementation of the compatibility profile is optional. 239 240 If the core profile is requested, then the context returned cannot 241 implement functionality defined only by the compatibility profile. 242 243 OpenGL and OpenGL ES Context Flags 244 ---------------------------------- 245 246 The value for attribute EGL_CONTEXT_FLAGS_KHR specifies a set of flag 247 bits affecting the context. Flag bits are only meaningful when creating 248 certain types of contexts, as described for each bit below, and 249 specifying such a flag bit when creating another type of context will 250 generate an error. 251 252 If the EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR flag bit is set in 253 EGL_CONTEXT_FLAGS_KHR, then a <debug context> will be created. Debug 254 contexts are intended for use during application development, to 255 provide additional runtime checking, validation, and logging 256 functionality while possibly incurring performance penalties. The 257 additional functionality provided by debug contexts may vary 258 according to the implementation(fn). In some cases a debug context 259 may be identical to a non-debug context. This bit is supported for 260 OpenGL and OpenGL ES contexts. 261 [fn: Khronos is still defining the expected and required 262 features of debug contexts, so implementations are 263 currently free to implement "debug contexts" with little or 264 no debug functionality. However, OpenGL and OpenGL ES 265 implementations supporting the GL_KHR_debug extension 266 should enable it when this bit is set.] 267 [fn2: See issue 9 below for discussion of backwards 268 compatibility issues with the debug bit and OpenGL ES 269 contexts.] 270 271 If the EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR flag bit is set 272 in EGL_CONTEXT_FLAGS_KHR, then a <forward-compatible> context will 273 be created. Forward-compatible contexts are defined only for OpenGL 274 versions 3.0 and later. They must not support functionality marked 275 as <deprecated> by that version of the API, while a 276 non-forward-compatible context must support all functionality in 277 that version, deprecated or not. This bit is supported for OpenGL 278 contexts, and requesting a forward-compatible context for OpenGL 279 versions less than 3.0 will generate an error. 280 281 If the EGL_CONTEXT_OPENGL_ROBUST_ACCESS_BIT_KHR bit is set in 282 EGL_CONTEXT_FLAGS_KHR, then a context supporting <robust buffer 283 access> will be created. Robust buffer access is defined in the 284 GL_ARB_robustness extension specification, and the resulting context 285 must also support either the GL_ARB_robustness extension, or a 286 version of OpenGL incorporating equivalent functionality. This bit 287 is supported for OpenGL contexts. 288 289 The default value of EGL_CONTEXT_FLAGS_KHR is zero. 290 291 OpenGL Context Reset Notification 292 --------------------------------- 293 294 The attribute name 295 EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR specifies the 296 <reset notification behavior> of the rendering context. This 297 attribute is only meaningful for OpenGL contexts, and specifying it 298 for other types of contexts, including OpenGL ES contexts, will 299 generate an error. 300 301 Reset notification behavior is defined in the GL_ARB_robustness 302 extension specification, and the resulting context must also support 303 either the GL_ARB_robustness extension, or a version of OpenGL or 304 incorporating equivalent functionality. The attribute value may be 305 either EGL_NO_RESET_NOTIFICATION_KHR or 306 EGL_LOSE_CONTEXT_ON_RESET_KHR, which respectively result in reset 307 notification behavior of GL_NO_RESET_NOTIFICATION_ARB and 308 GL_LOSE_CONTEXT_ON_RESET_ARB, as described by GL_ARB_robustness. The 309 default value for EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR 310 is EGL_NO_RESET_NOTIFICATION_KHR. 311 312 Errors 313 ------ 314 315 On failure eglCreateContext returns EGL_NO_CONTEXT and generates an 316 EGL error with extended error information. Conditions that cause 317 failure include: 318 319 * If an attribute is specified that is not meaningful for the 320 client API type determined by the current rendering API, an 321 EGL_BAD_ATTRIBUTE error is generated. 322 323 * If the current rendering api is EGL_NONE, then an EGL_BAD_MATCH 324 error is generated (this situation can only arise in an 325 implementation which does not support OpenGL ES 1.x, and prior to 326 the first call to eglBindAPI). 327 328 * If share_context is neither EGL_NO_CONTEXT nor a valid context 329 of the same client API type as the newly created context, then 330 an EGL_BAD_CONTEXT error is generated. 331 332 * If <config> is not a valid EGLConfig, or does not support the 333 requested client API, then an EGL_BAD_CONFIG error is generated 334 (this includes requesting creation of an OpenGL ES 1.x, 2.0, or 335 3.0 context when the EGL_RENDERABLE_TYPE attribute of <config> 336 does not contain EGL_OPENGL_ES_BIT, EGL_OPENGL_ES2_BIT, or 337 EGL_OPENGL_ES3_BIT_KHR respectively). 338 339 * If <config> does not support a client API context compatible 340 with the requested API major and minor version, context flags, 341 and context reset notification behavior (for client API types 342 where these attributes are supported), then an EGL_BAD_MATCH 343 error is generated. 344 345 * If an OpenGL context is requested, the requested version is 346 greater than 3.2, and the value for attribute 347 EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR has no bits set; has any 348 bits set other than EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR and 349 EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR; has more than 350 one of these bits set; or if the implementation does not support 351 the requested profile, then an EGL_BAD_MATCH error is generated. 352 353 * If an OpenGL or OpenGL ES context is requested and the server 354 context state for <share_context> exists in an address space 355 that cannot be shared with the newly created context, if 356 <share_context> was created on a different display than the one 357 referenced by <config>, if the reset notification behavior of 358 <share_context> and the newly created context are different, or 359 if the contexts are otherwise incompatible (for example, one 360 context being associated with a hardware device driver and the 361 other with a software renderer), then an EGL_BAD_MATCH error is 362 generated. 363 364 * If the server does not have enough resources to allocate the new 365 context, then an EGL_BAD_ALLOC error is generated. 366 367 * If an OpenGL context is requested and the values for attributes 368 EGL_CONTEXT_MAJOR_VERSION_KHR and EGL_CONTEXT_MINOR_VERSION_KHR, 369 when considered together with the value for attribute 370 EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR, specify an OpenGL 371 version and feature set that are not defined, than an 372 EGL_BAD_MATCH error is generated. 373 374 The defined versions of OpenGL at the time of writing are OpenGL 375 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 2.0, 2.1, 3.0, 3.1, 3.2, 4.0, 4.1, 376 4.2, and 4.3. Feature deprecation was introduced with OpenGL 377 3.0, so forward-compatible contexts may only be requested for 378 OpenGL 3.0 and above. Thus, examples of invalid combinations of 379 attributes include: 380 381 - Major version < 1 or > 4 382 - Major version == 1 and minor version < 0 or > 5 383 - Major version == 2 and minor version < 0 or > 1 384 - Major version == 3 and minor version < 0 or > 2 385 - Major version == 4 and minor version < 0 or > 3 386 - Forward-compatible flag set and major version < 3 387 388 Because the purpose of forward-compatible contexts is to allow 389 application development on a specific OpenGL version with the 390 knowledge that the app will run on a future version, context 391 creation will fail if 392 EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR is set and the 393 context version returned cannot implement exactly the requested 394 version. 395 396 * If an OpenGL ES context is requested and the values for 397 attributes EGL_CONTEXT_MAJOR_VERSION_KHR and 398 EGL_CONTEXT_MINOR_VERSION_KHR specify an OpenGL ES version that 399 is not defined, than an EGL_BAD_MATCH error is generated. 400 401 The defined versions of OpenGL ES at the time of writing are 402 OpenGL ES 1.0, 1.1, 2.0, and 3.0. Examples of invalid 403 combinations of attributes include: 404 405 - Major version < 1 or > 3 406 - Major version == 1 and minor version < 0 or > 1 407 - Major version == 2 and minor version != 0 408 - Major version == 3 and minor version != 0 409 410 * If an attribute name or attribute value in <attrib_list> is not 411 recognized (including undefined or unsupported bits in bitmask 412 attributes), then an EGL_BAD_ATTRIBUTE error is generated." 413 414 In section 3.7.3, replace the following two error conditions in the 415 list of eglMakeCurrent errors: 416 417 " * If <ctx> is not a valid context, an EGL_BAD_CONTEXT error is 418 generated. 419 * If either <draw> or <read> are not valid EGL surfaces, an 420 EGL_BAD_SURFACE error is generated." 421 422 with the following error conditions: 423 424 " * If <ctx> is not a valid context and is not EGL_NO_CONTEXT, an 425 EGL_BAD_CONTEXT error is generated. 426 * If either <draw> or <read> are not valid EGL surfaces and are 427 not EGL_NO_SURFACE, an EGL_BAD_SURFACE error is generated. 428 * If <ctx> is EGL_NO_CONTEXT and either <draw> or <read> are not 429 EGL_NO_SURFACE, an EGL_BAD_MATCH error is generated. 430 * If either of <draw> or <read> is a valid surface and the other 431 is EGL_NO_SURFACE, an EGL_BAD_MATCH error is generated. 432 * If <ctx> does not support being bound without read and draw 433 surfaces, and both <draw> and <read> are EGL_NO_SURFACE, an 434 EGL_BAD_MATCH error is generated." 435 436 Replace the paragraph starting "If <ctx> is EGL_NO_CONTEXT and 437 <draw> and <read> are not EGL_NO_SURFACE..." with 438 439 "If both <draw> and <read> are EGL_NO_SURFACE, and <ctx> is an OpenGL 440 context supporting version 3.0 or later of the OpenGL API, then no 441 error is generated and the context is made current without a 442 <default framebuffer>. The meaning of this is defined in chapter 4 443 of the OpenGL 3.0 Specification." 444 445 Append to the paragraph starting "The first time an OpenGL or OpenGL 446 ES context is made current..." with 447 448 "If the first time <ctx> is made current, it is without a default 449 framebuffer (e.g. both <draw> and <read> are EGL_NO_SURFACE), then 450 the viewport and scissor regions are set as though 451 glViewport(0,0,0,0) and glScissor(0,0,0,0) were called." 452 453 454Errors 455 456 EGL errors for eglCreateContext as described in the body of the 457 specification. 458 459 eglMakeCurrent error behavior is relaxed to allow making an OpenGL 460 3.0 or later context current without a default read or draw 461 framebuffer. 462 463Conformance Tests 464 465 TBD 466 467Sample Code 468 469 TBD 470 471Issues 472 473 Non-window-system dependent issues described in the 474 WGL_ARB_create_context extension specification in the OpenGL 475 Registry apply to EGL_KHR_create_context. 476 477 1) Do enumerant values need to be shared with the equivalent WGL / GLX 478 extensions? 479 480 Mostly not. The only case where it's fairly important that the 481 values be identical is the EGL_CONTEXT_FLAGS_KHR attribute bitmask 482 values, which are also exposed through an OpenGL query. 483 484 2) Why are some attribute values named EGL_CONTEXT_OPENGL_*? 485 486 It is possible that context flags and profiles will eventually be 487 defined for client APIs other than OpenGL. To allow for this 488 possibility, the names of the corresponding attribute values are 489 distinguished. For example, EGL_CONTEXT_FLAGS_KHR currently only has 490 flags defined for OpenGL context creation, and those flags are named 491 EGL_CONTEXT_OPENGL_*_BIT_KHR, but in time OpenVG context creation 492 might allow flags as well. Such flags would be named 493 EGL_CONTEXT_OPENVG_*_BIT_KHR. 494 495 3) Why does EGL_CONTEXT_MAJOR_VERSION_KHR have a distinct numeric token 496 value when it is functionally equivalent to 497 EGL_CONTEXT_CLIENT_VERSION? 498 499 It no longer has a distinct token value; see issue 1. 500 501 4) How will future versions of OpenGL ES interact with this extension? 502 503 Later context versions which are backwards compatibile with the 504 requested version can be returned, just as with OpenGL contexts. 505 506 5) What happens when requesting a context requiring OpenGL functionality 507 that cannot be supported by the underlying GL implementation, such as 508 requesting lost context reset notification and/or robust buffer access 509 when the implementation does not support the functionality defined by 510 GL_ARB_robustness? 511 512 Context creation will fail and an EGL_BAD_MATCH error will be 513 generated. This case is included under the general language of the 514 fifth bullet point under "Errors" but this issue is added to for 515 clarity. 516 517 6) How is robust buffer access and reset notification supported under 518 OpenGL ES? 519 520 RESOLVED: It is an error to request robust buffer access and/or reset 521 notification for OpenGL ES contexts. Exposing robust buffer access and 522 reset notification for OpenGL ES contexts may be defined in a future EGL 523 extension. 524 525 7) Future support for OpenGL ES context creation. 526 527 If and when features available for OpenGL context creation are defined 528 for OpenGL ES context creation in the future, debug contexts, forward 529 compatible contexts, and robust buffer access contexts may be specified 530 using separate attributes rather than bitmasks. The reset notification 531 behavior attribute may be extended to cover OpenGL ES as well as OpenGL. 532 533 8) Why was the EGL_OPENGL_ES3_BIT_KHR added in version 13 of the 534 extension? Doesn't this break backwards compatibility with older 535 versions of the extension? 536 537 Applications need the functionality to be confident that context 538 creation of an OpenGL ES 3.0 context will succeed (rather than trying 539 it with different configs until one that succeeds is found). 540 541 If this bit is passed into eglChooseConfig and the implementation 542 supports only an older version of the extension, an EGL_BAD_ATTIBUTE 543 error should be generated. Since no matching configs will be found, a 544 robustly-written application will fail (or fall back to an ES 2.0 545 rendering path) at this point. This is the same application behavior 546 that should result from not finding a matching config on an 547 implementation supporting version 13 of the extension, even though the 548 failure mode is different (EGL error vs. returning no matching 549 configs). The EGL Working Group considers this sufficiently benign 550 behavior, and the functionality important enough, to make the change. 551 552 9) Why was OpenGL ES support for EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR added 553 in version 15 of the extension? Doesn't this break backwards 554 compatibility with older versions of the extension? 555 556 Now that the GL_KHR_debug extension is ratified and available, 557 OpenGL ES implementers needed a way to enable debug functionality, 558 and wanted to use the same mechanism as OpenGL. There is no 559 discovery mechanism for this capability, so an application creating 560 a OpenGL ES context with the debug bit set and running against an 561 older EGL driver should generate an error. The OpenGL ES Working 562 Group considers this benign behavior. 563 564 10) Which error should be generated if robust buffer access or reset 565 notifications are requested under OpenGL ES? 566 567 As per Issue 6, this extension does not support creating robust contexts 568 for OpenGL ES. This is only supported via the EGL_EXT_create_context_- 569 robustness extension. 570 571 Attempting to use this extension to create robust OpenGL ES context 572 will generate an EGL_BAD_ATTRIBUTE error. This specific error is generated 573 because this extension does not define the EGL_CONTEXT_OPENGL_ROBUST_- 574 ACCESS_BIT_KHR and EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_KHR bits 575 for OpenGL ES contexts. Thus, use of these bits fall under condition 576 described by: "If an attribute is specified that is not meaningful for 577 the client API type.." in the above specification. 578 579Revision History 580 581 Version 16, 2015/01/15 582 - Add issue 10. 583 584 Version 15, 2013/03/27 585 - Add OpenGL ES support for debug contexts (Bug 10035). 586 587 Version 14, 2012/09/19 588 - Assign enum value to new bit and published updated extension. 589 590 Version 13, 2012/07/29 591 - Add EGL_OPENGL_ES3_BIT_KHR to table 3.3 and sections 3.5.2, 3.7, 592 and 3.7.1. Add issue 8 explaining the addition. 593 594 Version 12, 2012/07/25 595 - Explicitly describe new OpenGL 4.3 and OpenGL ES 3.0 versions. 596 This is not a behavior change (Khronos Bug 9136). 597 - Make spec consistent so that asking for a forward-compatible GL 598 context for versions less than 3.0 is an error (Bug 9314). 599 - Change nonexistent EGL_BAD_PROFILE_KHR error generated when 600 asking for an unsupported or nonexistent GL profile to an 601 EGL_BAD_MATCH error (Bug 9314). 602 - Fix typos in spec body for several new tokens of form 603 "EGL_CONTEXT_OPENGL_*" which were missing the "OPENGL_" part 604 (Bug 9314). 605 606 Version 11, 2012/07/09 - change nonexistent EGL_BAD_VALUE error 607 to EGL_BAD_ATTRIBUTE (Khronos Bug 9269). 608 609 Version 10, 2011/11/22 - fix typo. 610 611 Version 9, 2011/11/09 - resolve issue 6 and add issue 7, limiting 612 various context creation attributes to apply only to OpenGL and not 613 to OpenGL ES. 614 615 Version 8, 2011/10/20 - change spec body to match BAD_MATCH error 616 returned in issue 5 when specifying context version and attributes 617 that collectively cannot be satisfied. 618 619 Version 7, 2011/10/19 - add issue 5 clarifying context creation 620 failures when requesting functionality that cannot be supported by a 621 GL or ES context, and issue 6 discussing the meaning of "equivalent 622 to GL_ARB_robustness". 623 624 Version 6, 2011/10/19 - minor cleanup & clarification of OpenGL ES 625 version requests. 626 627 Version 5, 2010/09/22 - add context reset notification strategy 628 attributes from GLX/WGL context creation extensions. 629 630 Version 4, 2010/09/22 - fix typo. Assign enumerant values and update 631 issue 1 to match. Add caveat to errors section so that invalid 632 attribute values for EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR only raise 633 errors when requesting an OpenGL context of version 3.2 or greater 634 (bug 6374). Add issue 4 and allow ES 2.0 context creation requests 635 to return later versions that are backwards-compatible (bug 6374). 636 637 Version 3, 2010/07/21 - remove surfaceless bit in favor of separate 638 per-client-API extensions which promise that contexts of a given 639 client API type can be bound without surfaces on that display. Add 640 robust buffer access bit from equivalent WGL/GLX context creation 641 extensions. Rename EGL_CONTEXT_FLAGS_KHR so it's not specific to 642 OpenGL. 643 644 Version 2, 2010/06/29 - add EGL_CONTEXT_OPENGL_SURFACELESS_BIT_KHR 645 context flag bit (bug 6082). 646 647 Version 1, 2010/06/29 - Initial version based on equivalent 648 WGL_ARB_create_context and GLX_ARB_create_context extensions. 649