1Name 2 3 ARB_create_context 4 ARB_create_context_profile 5 6Name Strings 7 8 GLX_ARB_create_context 9 GLX_ARB_create_context_profile 10 11Contact 12 13 Jon Leech (jon 'at' alumni.caltech.edu) 14 15Notice 16 17 Copyright (c) 2009-2013 The Khronos Group Inc. Copyright terms at 18 http://www.khronos.org/registry/speccopyright.html 19 20Specification Update Policy 21 22 Khronos-approved extension specifications are updated in response to 23 issues and bugs prioritized by the Khronos OpenGL Working Group. For 24 extensions which have been promoted to a core Specification, fixes will 25 first appear in the latest version of that core Specification, and will 26 eventually be backported to the extension document. This policy is 27 described in more detail at 28 https://www.khronos.org/registry/OpenGL/docs/update_policy.php 29 30IP Status 31 32 No known IP claims. 33 34Status 35 36 Complete. Approved by the ARB on July 28, 2009. 37 Approved by the Khronos Board of Promoters on August 28, 2009. 38 Version 8 update approved by the ARB on September 24, 2009. 39 40Version 41 42 Version 10, 2012/03/28 43 44Number 45 46 ARB Extension #56 (GLX_ARB_create_context) 47 ARB Extension #75 (GLX_ARB_create_context_profile) 48 49Dependencies 50 51 GLX 1.4 is required. 52 53 Some of the capabilities of these extensions are only available with 54 contexts supporting OpenGL 3.0 or later. 55 56 The presence of an OpenGL 3.2 or later implementation determines 57 whether or not GLX_ARB_create_context_profile is required. 58 59Overview 60 61 With the advent of new versions of OpenGL which deprecate features 62 and/or break backward compatibility with older versions, there is a 63 need and desire to indicate at context creation which interface will 64 be used. These extensions add a new context creation routine with 65 attributes specifying the GL version and context properties 66 requested for the context, and additionally add an attribute 67 specifying the GL profile requested for a context of OpenGL 3.2 or 68 later. It also allows making an OpenGL 3.0 or later context current 69 without providing a default framebuffer. 70 71New Procedures and Functions 72 73 GLXContext glXCreateContextAttribsARB( 74 Display *dpy, GLXFBConfig config, 75 GLXContext share_context, Bool direct, 76 const int *attrib_list); 77 78New Tokens 79 80 Accepted as an attribute name in <*attrib_list>: 81 82 GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091 83 GLX_CONTEXT_MINOR_VERSION_ARB 0x2092 84 GLX_CONTEXT_FLAGS_ARB 0x2094 85 GLX_CONTEXT_PROFILE_MASK_ARB 0x9126 86 87 Accepted as bits in the attribute value for GLX_CONTEXT_FLAGS_ARB in 88 <*attrib_list>: 89 90 GLX_CONTEXT_DEBUG_BIT_ARB 0x0001 91 GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 92 93 Accepted as bits in the attribute value for 94 GLX_CONTEXT_PROFILE_MASK_ARB in <*attrib_list>: 95 96 GLX_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 97 GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 98 99Additions to the OpenGL / WGL Specifications 100 101 None. This specification is written for GLX. 102 103Additions to the GLX 1.4 Specification 104 105 Replace the initial six paragraphs of section 3.3.7 "Rendering 106 Contexts", describing glXCreateNewContext, with: 107 108 "To create an OpenGL rendering context, call 109 110 GLXContext glXCreateContextAttribsARB( 111 Display *dpy, 112 GLXFBConfig config, 113 GLXContext share_context, 114 Bool direct, 115 const int *attrib_list); 116 117 If glXCreateContextAttribsARB succeeds, it initializes the context 118 to the initial state defined by the OpenGL specification, and 119 returns a handle to it. This handle can be used to render to any GLX 120 surface (window, pixmap, or pbuffer) compatible with <config>, 121 subject to constraints imposed by the OpenGL API version of the 122 context. 123 124 If <share_context> is not NULL, then all shareable data (excluding 125 OpenGL texture objects named 0) will be shared by <share_context>, 126 all other contexts <share_context> already shares with, and the 127 newly created context. An arbitrary number of GLXContexts can share 128 data in this fashion. The server context state for all sharing 129 contexts must exist in a single address space. 130 131 Direct rendering is requested if <direct> is True, and indirect 132 rendering if <direct> is False. If <direct> is True, the 133 implementation may nonetheless create an indirect rendering context 134 if any of the following conditions hold: 135 136 * The implementation does not support direct rendering. 137 * <display> is not a local X server. 138 * Implementation-dependent limits on the number of direct 139 rendering contexts that can be supported simultaneously are 140 exceeded. 141 142 Use glXIsDirect (see below) to determine whether or not a request 143 for a direct rendering context succeeded. 144 145 <attrib_list> specifies a list of attributes for the context. The 146 list consists of a sequence of <name,value> pairs terminated by the 147 value None (0). If an attribute is not specified in <attrib_list>, 148 then the default value specified below is used instead. 149 150 <attrib_list> may be NULL or empty (first attribute is None), in 151 which case all attributes assume their default values as described 152 below. 153 154 The attribute names GLX_CONTEXT_MAJOR_VERSION_ARB and 155 GLX_CONTEXT_MINOR_VERSION_ARB request an OpenGL context supporting 156 the specified version of the API. If successful, the context 157 returned must be backwards compatible with the context requested. 158 Backwards compatibility is determined as follows: 159 160 If a version less than or equal to 3.0 is requested, the context 161 returned may implement any of the following versions: 162 163 * Any version no less than that requested and no greater than 3.0. 164 * Version 3.1, if the GL_ARB_compatibility extension is also 165 implemented. 166 * The compatibility profile of version 3.2 or greater. 167 168 If version 3.1 is requested, the context returned may implement 169 any of the following versions: 170 171 * Version 3.1. The GL_ARB_compatibility extension may or may not 172 be implemented, as determined by the implementation. 173 * The core profile of version 3.2 or greater. 174 175 If version 3.2 or greater is requested, the context returned may 176 implement any of the following versions: 177 178 * The requested profile of the requested version. 179 * The requested profile of any later version, so long as no 180 features have been removed from that later version and profile. 181 182 Querying the GL_VERSION string with glGetString (or the 183 GL_MAJOR_VERSION and GL_MINOR_VERSION values with glGetIntegerv, in 184 a 3.0 or later context) will return the actual version supported by 185 a context. 186 187 The default values for GLX_CONTEXT_MAJOR_VERSION_ARB and 188 GLX_CONTEXT_MINOR_VERSION_ARB are 1 and 0 respectively. In this 189 case, implementations will typically return the most recent version 190 of OpenGL they support which is backwards compatible with OpenGL 1.0 191 (e.g. 3.0, 3.1 + GL_ARB_compatibility, or 3.2 compatibility profile) 192 193 The attribute name GLX_CONTEXT_PROFILE_MASK_ARB requests an OpenGL 194 context supporting a specific <profile> of the API. If the 195 GLX_CONTEXT_CORE_PROFILE_BIT_ARB bit is set in the attribute value, 196 then a context implementing the <core> profile of OpenGL is 197 returned. If the GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB bit is 198 set, then a context implementing the <compatibility> profile is 199 returned. If the requested OpenGL version is less than 3.2, 200 GLX_CONTEXT_PROFILE_MASK_ARB is ignored and the functionality of the 201 context is determined solely by the requested version. 202 203 Querying the value of GL_CONTEXT_PROFILE_MASK with glGetIntegerv 204 will return the profile mask used to create the context. This query 205 is only supported in an OpenGL 3.2 or later context. 206 207 The default value for GLX_CONTEXT_PROFILE_MASK_ARB is 208 GLX_CONTEXT_CORE_PROFILE_BIT_ARB. All OpenGL 3.2 implementations are 209 required to implement the core profile, but implementation of the 210 compatibility profile is optional. 211 212 If the core profile is requested, then the context returned cannot 213 implement functionality defined only by the compatibility profile. 214 215 The attribute name GLX_CONTEXT_FLAGS_ARB specifies a set of flag 216 bits affecting the rendering context. 217 218 If the GLX_CONTEXT_DEBUG_BIT_ARB flag bit is set in 219 GLX_CONTEXT_FLAGS_ARB, then a <debug context> will be created. Debug 220 contexts are intended for use during application development, and 221 provide additional runtime checking, validation, and logging 222 functionality while possibly incurring performance penalties. The 223 additional functionality provided by debug contexts may vary 224 according to the implementation(fn). In some cases a debug context 225 may be identical to a non-debug context. 226 [fn: The ARB Ecosystem TSG is still defining the expected and 227 required features of debug contexts.] 228 229 If the GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB is set in 230 GLX_CONTEXT_FLAGS_ARB, then a <forward-compatible> context will be 231 created. Forward-compatible contexts are defined only for OpenGL 232 versions 3.0 and later. They must not support functionality marked 233 as <deprecated> by that version of the API, while a 234 non-forward-compatible context must support all functionality in 235 that version, deprecated or not. 236 237 The default value of GLX_CONTEXT_FLAGS_ARB is 0. 238 239 The attribute name GLX_RENDER_TYPE specifies the type of rendering 240 to be supported by the context. RGBA rendering is supported if the 241 attribute value is GLX_RGBA_TYPE, and color index rendering is 242 supported if the attribute value is GLX_COLOR_INDEX_TYPE. The 243 default value of GLX_RENDER_TYPE is GLX_RGBA_TYPE. OpenGL contexts 244 supporting version 3.0 or later of the API do not support color 245 index rendering, even if a color index <config> is available. 246 247 On failure glXCreateContextAttribsARB returns NULL and generates an 248 X error with extended error information. Conditions that cause 249 failure include: 250 251 * If the server context state for <share_context> exists in an 252 address space that cannot be shared with the newly created 253 context, if <share_context> was created on a different screen 254 than the one referenced by <config>, or if the contexts are 255 otherwise incompatible (for example, one context being 256 associated with a hardware device driver and the other with a 257 software renderer), BadMatch is generated. 258 259 * If the server does not have enough resources to allocate the new 260 context, BadAlloc is generated. 261 262 * If <share_context> is neither zero nor a valid GLX rendering 263 context, GLXBadContext is generated. 264 265 * If <config> is not a valid GLXFBConfig, GLXBadFBConfig is 266 generated. 267 268 * If attribute GLX_RENDER_TYPE does not describe a valid rendering 269 type, BadValue is generated. 270 271 * If attributes GLX_CONTEXT_MAJOR_VERSION_ARB and 272 GLX_CONTEXT_MINOR_VERSION_ARB, when considered together with 273 attributes GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB and 274 GLX_RENDER_TYPE, specify an OpenGL version and feature set that 275 are not defined, BadMatch is generated. 276 277 The defined versions of OpenGL at the time of writing are OpenGL 278 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 2.0, 2.1, 3.0, 3.1, and 3.2. 279 Feature deprecation was introduced with OpenGL 3.0, so 280 forward-compatible contexts may only be requested for OpenGL 3.0 281 and above. Thus, examples of invalid combinations of attributes 282 include: 283 284 - Major version < 1 or > 3 285 - Major version == 1 and minor version < 0 or > 5 286 - Major version == 2 and minor version < 0 or > 1 287 - Major version == 3 and minor version > 2 288 - Forward-compatible flag set and major version < 3 289 - Color index rendering and major version >= 3 290 291 Because the purpose of forward-compatible contexts is to allow 292 application development on a specific OpenGL version with the 293 knowledge that the app will run on a future version, context 294 creation will fail if GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB is 295 set and the context version returned cannot implement exactly 296 the requested version. 297 298 * If attribute GLX_CONTEXT_PROFILE_MASK_ARB has no bits set; has 299 any bits set other than GLX_CONTEXT_CORE_PROFILE_BIT_ARB and 300 GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; has more than one of 301 these bits set; or if the implementation does not support the 302 requested profile, then GLXBadProfileARB is generated. 303 304 * If <config> does not support compatible OpenGL contexts 305 providing the requested API major and minor version, 306 forward-compatible flag, and debug context flag, GLXBadFBConfig 307 is generated. 308 309 * If an attribute or attribute value in <attrib_list> 310 is not recognized (including unrecognized bits in bitmask 311 attributes), BadValue is generated. 312 313 3.3.7.1 Legacy Context Creation 314 ------------------------------- 315 316 To create an OpenGL rendering context of version 2.1 or below, call 317 318 GLXContext glXCreateNewContext( 319 Display *dpy, 320 GLXFBConfig config, 321 int render_type, 322 GLXContext share_list, 323 Bool direct); 324 325 Calling glXCreateNewContext is equivalent to the command sequence 326 327 int attrib_list[] = { 328 GLX_RENDER_TYPE, render_type, 329 None 330 }; 331 332 glXCreateContextAttribs(dpy, config, share_list, direct, attrib_list); 333 334 The legacy context creation routines can only return OpenGL 3.1 335 contexts if the GL_ARB_compatibility extension is supported, and can 336 only return OpenGL 3.2 or greater contexts implementing the 337 compatibility profile. This ensures compatibility for existing 338 applications. However, 3.0-aware applications are encouraged to use 339 wglCreateContextAttribsARB instead of the legacy routines. 340 341 To determine if an OpenGL rendering context is direct, call..." 342 343 344 In the description of glXMakeContextCurrent, replace the text 345 346 "If either <draw> or <read> are not a valid GLX drawable, a 347 GLXBadDrawable error is generated." 348 349 with 350 351 "If either <draw> or <read> are not a valid GLX drawable, a 352 GLXBadDrawable error is generated, unless <draw> and <read> are both 353 None and the OpenGL version supported by <ctx> is 3.0 or greater. In 354 this case the context is made current without a default framebuffer, 355 as defined in chapter 4 of the OpenGL 3.0 Specification." 356 357 Replace the text 358 359 "To release the current context without assigning a new one, set 360 <ctx> to NULL and set <draw> and <read> to None. If <ctx> is NULL 361 and <draw> and <read> are not None, or if <draw> or <read> are set 362 to None and <ctx> is not NULL, then a BadMatch error will be 363 generated." 364 365 with 366 367 "To release the current context without assigning a new one, set 368 <ctx> to NULL and set <draw> and <read> to None. A BadMatch 369 error will be generated under any of the following conditions: 370 371 * <ctx> is NULL, and either or both of <draw> and <read> are not 372 None. 373 * <ctx> is not NULL, and exactly one of <draw> or <read> is None. 374 * <ctx> is not NULL, both <draw> or <read> are None, and the 375 OpenGL version supported by <ctx> is less than 3.0." 376 377 After the sentence 378 379 "The first time <ctx> is made current, the viewport and scissor 380 dimensions are set to the size of the draw drawable (as though 381 glViewport(0,0,w,h) and glScissor(0,0,w,h) were called, where <w> 382 and <h> are the width and height of the drawable, respectively)." 383 384 insert 385 386 "If the first time <ctx> is made current, it is without a default 387 framebuffer (e.g. both <draw> and <read> are None), then the 388 viewport and scissor regions are set as though glViewport(0,0,0,0) 389 and glScissor(0,0,0,0) were called." 390 391GLX Errors 392 393 GLXBadProfileARB 394 395 The requested context profile is invalid or not supported. 396 397 BEC is the base error code for the extension, as returned by 398 XQueryExtension. 399 400 Encoding: 401 402 1 0 Error 403 1 BEC + 13 Error code (GLXBadProfileARB) 404 2 CARD16 sequence number 405 4 CARD32 bad profile bitmask 406 2 CARD16 minor opcode 407 1 CARD8 major opcode 408 21 unused 409 410GLX Protocol 411 412 Three new GLX protocol commands are added. 413 414 Send Extended Client Information To The Server (glXSetClientInfoARB 415 and glXSetClientInfo2ARB) 416 ---------------------------------------------- 417 418 This request is sent to the server during initialization, describing 419 the GLX version, GLX extensions, GL version(s), and GL extensions 420 supported by the client. The client needs to send only names of GL 421 extensions that require server support, but must send all GLX 422 extension names. 423 424 When the server receives a GetString request, it uses this 425 information to compute the version and extensions that can be 426 supported on the connection. The GLX client library should append 427 any client-side only extensions to the extension string returned by 428 the GetString request. When the server receives a 429 glXCreateContextAttribsARB request, it uses this information to 430 determine whether the requested context version, attributes, and 431 flags can be supported on the connection. 432 433 glXSetClientInfo2ARB supersedes glXSetClientInfoARB, which in turn 434 supersedes the glXClientInfo request. The client should only send 435 glXSetClientInfo2ARB if both GLX_ARB_create_context and 436 GLX_ARB_create_context_profile are present in the server's extension 437 string. If only GLX_ARB_create_context is present, the client 438 should send glXSetClientInfoARB, and if neither are present 439 glXClientInfo should be sent. If none of these requests are ever 440 sent to the server, the server assumes the client supports OpenGL 441 major version 1 and minor version 0, GLX major version 1, and minor 442 version 0, and doesn't support any OpenGL or GLX extensions. 443 444 glXSetClientInfo2ARB Encoding: 445 446 1 CARD8 opcode (X assigned) 447 1 35 GLX opcode (glXSetClientInfoARB) 448 2 6+(n0*3)+((n1+p1)/4)+((n2+p2)/4) request length 449 4 CARD32 client GLX major version 450 4 CARD32 client GLX minor version 451 4 n0 number of context versions 452 4 n1 number of bytes in extension_string 453 4 n2 number of bytes in glx_extension_string 454 n0*3*4 LISTofCARD32 context versions 455 n1 STRING8 client GL extension string 456 p1 unused, p1 = pad(n1) 457 n2 STRING8 client GLX extension string 458 p2 unused, p2 = pad(n2) 459 460 glXSetClientInfoARB Encoding: 461 462 1 CARD8 opcode (X assigned) 463 1 33 GLX opcode (glXSetClientInfoARB) 464 2 6+(n0*2)+((n1+p1)/4)+((n2+p2)/4) request length 465 4 CARD32 client GLX major version 466 4 CARD32 client GLX minor version 467 4 n0 number of context versions 468 4 n1 number of bytes in extension_string 469 4 n2 number of bytes in glx_extension_string 470 n0*2*4 LISTofCARD32 context versions 471 n1 STRING8 client GL extension string 472 p1 unused, p1 = pad(n1) 473 n2 STRING8 client GLX extension string 474 p2 unused, p2 = pad(n2) 475 476 "Context versions" is a list of (major version, minor version, 477 [profile mask]) tuple; each tuple describes a GL version supported 478 by the client. The profile mask member is only sent when using 479 glXSetClientInfo2ARB and is ignored for versions less than 3.2. 480 Only the highest supported version below 3.0 should be sent, since 481 OpenGL 2.1 is backwards compatible with all earlier versions. For 482 example, a context versions array containing 483 484 { 2, 1, 0x0, 3, 0, 0x0, 3, 1, 0x0, 3, 2, 0x3 } 485 486 Means that the client supports all GL versions between 1.0 and 2.1, 487 as well as versions 3.0, 3.1, and 3.2. Version 3.2 core and 488 compatibility profiles are supported. A BadValue error will be 489 generated if the client sends a 3.2 or greater version tuple with a 490 profile mask of 0, or with a profile mask that does not include the 491 core profile. 492 493 If glXSetClientInfo2ARB or glXSetClientInfoARB are not sent by the 494 client prior to context creation the server will behave as if no 495 contexts above version 2.1 are supported, and assume the client 496 supports all GLX extensions. If the client sends 497 glXSetClientInfoARB and the server supports 498 GLX_ARB_create_context_profile, the server will behave as if no 499 contexts above version 3.1 are supported. 500 501 502 Context Creation with Attributes (glXCreateContextAttribsARB) 503 -------------------------------- 504 505 This request is sent to create a context with specified attributes 506 507 1 CARD8 opcode (X assigned) 508 1 34 GLX opcode (glXCreateContextAttribsARB) 509 2 7+n request length 510 4 GLX_CONTEXT context 511 4 FBCONFIGID fbconfig 512 4 CARD32 screen 513 4 GLX_CONTEXT share_context 514 1 BOOL isdirect 515 1 CARD8 reserved1 516 2 CARD16 reserved2 517 4 CARD32 num_attribs 518 4*n LISTofATTRIBUTE_PAIR attribute, value pairs 519 520Errors 521 522 GLX errors for glXCreateContextAttribsARB and glXSetClientInfo2ARB 523 as described in the body of the specification. 524 525 glXMakeContextCurrent error behavior is relaxed to allow making an 526 OpenGL 3.0 or later context current without a default read or draw 527 framebuffer. 528 529Dependencies on GLX_ARB_create_context 530 531 If GLX_ARB_create_context_profile is supported, then 532 GLX_ARB_create_context must also be supported. 533 534Dependencies on OpenGL 3.2 and later OpenGL versions 535 536 If GLX_ARB_create_context is supported, and if the OpenGL 537 implementation supports OpenGL 3.2 or later, then 538 GLX_ARB_create_context_profile must also be supported. If the OpenGL 539 implementation does not support OpenGL 3.2 or later, then 540 GLX_ARB_create_context_profile may or may not be supported. 541 542 If GLX_ARB_create_context_profile is not supported, then the 543 GLX_CONTEXT_PROFILE_MASK_ARB attribute, the 544 GLX_CONTEXT_CORE_PROFILE_BIT_ARB and 545 GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB bits in that attribute, 546 and the ERROR_INVALID_PROFILE_ARB error are not defined, and 547 specifying the attribute in <attribList> attribute will generate 548 BadValue. 549 550New State 551 552 None 553 554New Implementation Dependent State 555 556 None 557 558Conformance Tests 559 560 TBD 561 562Sample Code 563 564 TBD 565 566Issues 567 568 All non-window-system dependent issues described in the 569 WGL_ARB_create_context extension specification apply equally to 570 GLX_ARB_create_context. 571 572 1) Why was the context creation parameter <render_type> folded into the 573 attribute list, while the parameters <direct> and <share_context> 574 remains explicit? 575 576 For <direct>, because different paths to the server may be taken for 577 creating direct contexts, and parsing the attribute list in the 578 client should not be required. For <share_context>, because putting 579 a GLXContext, which is implemented as a struct pointer, into a list 580 of 'int's does not work on LP64 architectures. 581 582 2) What is the behavior when creating an indirect rendering context 583 with attributes, flags, or a GLXFBConfig that require extensions not 584 supported by the client GLX implementation? 585 586 Context creation will succeed, but using such features may be 587 impossible, since there may be no entry points defined in the client 588 library to control them. 589 590 3) Does client support for profiles need to be sent to the server 591 along with client support for versions? 592 593 Yes. glXSetClientInfo2ARB extends glXSetClientInfoARB to support 594 sending supported profile masks for each supported version. 595 596Revision History 597 598 Version 1, 2008/08/20 - Fork from WGL_ARB_create_context 599 600 Version 2, 2008/08/21 - Add viewport/scissor setting behavior when 601 no default framebuffer is made current. 602 603 Version 3, 2008/10/08 - Restore <direct> as an explicit parameter 604 instead of an attribute. Allow creating indirect contexts requiring 605 extensions not supported by the client. Add GLX protocol. Use 606 existing GLX_RENDER_TYPE token. Rename some parameters following 607 existing conventions. Update Errors section. 608 609 Version 4, 2008/10/13 - Move "undefined behavior when successfully 610 creating a context requiring extensions not supported by the client" 611 language from the spec into the issues list. Remove unused 612 GLX_DIRECT_RENDERER_ARB token. Expand description of 613 glXSetClientInfoARB protocol negotiation. 614 615 Version 5, 2008/10/22 - Mark as complete and assign extension number 616 for the registry. 617 618 Version 6, 2008/10/24 - Renumber to ARB extension #55 - misplaced 619 into vendor extension numbering scheme at first. 620 621 Version 7, 2009/07/27 - Add profiled context creation functionality 622 (GLX_CONTEXT_PROFILE_MASK_ARB and the associated bit tokens). 623 Clarify that if the core profile is requested, the returned context 624 cannot restore functionality from the compatibility profile (issue 625 17 in WGL_ARB_create_context). Specify the interdependencies between 626 the two GLX extensions defined here and OpenGL 3.2, including the 627 requirement that GLX_ARB_create_context_profile be supported if an 628 OpenGL 3.2 or later implementation is supported. Add issue 3 on 629 sending profile support to the server. 630 631 Version 8, 2009/08/30 - Add glXSetClientInfo2ARB to support sending 632 profile masks with the versions as well. Specify which error is 633 generated in the case profile tokens are used with a server that 634 doesn't support them. Replace ERROR_INVALID_PROFILE_ARB with 635 GLXBadProfileARB and define its encoding. 636 637 Version 9, 2009/11/19 - Clarify that BEC in the BadProfile protocol 638 represents the base error code for the GLX extension. 639 640 Version 10, 2012/03/28 - Clarify error conditions when 641 glXMakeContextCurrent is called with a valid context and exactly one 642 None drawable. 643