1Name 2 3 WGL_ARB_create_context 4 WGL_ARB_create_context_profile 5 6Name Strings 7 8 WGL_ARB_create_context 9 WGL_ARB_create_context_profile 10 11Contact 12 13 Jon Leech (jon 'at' alumni.caltech.edu) 14 Michael Gold, NVIDIA (gold 'at' nvidia.com) 15 16Notice 17 18 Copyright (c) 2009-2013 The Khronos Group Inc. Copyright terms at 19 http://www.khronos.org/registry/speccopyright.html 20 21Specification Update Policy 22 23 Khronos-approved extension specifications are updated in response to 24 issues and bugs prioritized by the Khronos OpenGL Working Group. For 25 extensions which have been promoted to a core Specification, fixes will 26 first appear in the latest version of that core Specification, and will 27 eventually be backported to the extension document. This policy is 28 described in more detail at 29 https://www.khronos.org/registry/OpenGL/docs/update_policy.php 30 31IP Status 32 33 No known IP claims. 34 35Status 36 37 Complete. Approved by the ARB on July 28, 2009. 38 Approved by the Khronos Board of Promoters on August 28, 2009. 39 40Version 41 42 July 28, 2009 (version 20) 43 44Number 45 46 ARB Extension #55 (WGL_ARB_create_context) 47 ARB Extension #74 (WGL_ARB_create_context_profile) 48 49Dependencies 50 51 WGL_ARB_extensions_string is required. 52 53 The presence of an OpenGL 3.2 or later implementation determines 54 whether or not WGL_ARB_create_context_profile is required. 55 56Overview 57 58 With the advent of new versions of OpenGL which deprecate features 59 and/or break backward compatibility with older versions, there is a 60 need and desire to indicate at context creation which interface will 61 be used. These extensions add a new context creation routine with 62 attributes specifying the GL version and context properties 63 requested for the context, and additionally add an attribute 64 specifying the GL profile requested for a context of OpenGL 3.2 or 65 later. 66 67New Procedures and Functions 68 69 HGLRC wglCreateContextAttribsARB(HDC hDC, HGLRC hShareContext, 70 const int *attribList) 71 72New Tokens 73 74 Accepted as an attribute name in <*attribList>: 75 76 WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 77 WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 78 WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 79 WGL_CONTEXT_FLAGS_ARB 0x2094 80 WGL_CONTEXT_PROFILE_MASK_ARB 0x9126 81 82 Accepted as bits in the attribute value for WGL_CONTEXT_FLAGS in 83 <*attribList>: 84 85 WGL_CONTEXT_DEBUG_BIT_ARB 0x0001 86 WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 87 88 Accepted as bits in the attribute value for 89 WGL_CONTEXT_PROFILE_MASK_ARB in <*attribList>: 90 91 WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 92 WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 93 94 New errors returned by GetLastError: 95 96 ERROR_INVALID_VERSION_ARB 0x2095 97 ERROR_INVALID_PROFILE_ARB 0x2096 98 99Additions to the OpenGL / GLX / GLX Protocol Specificaitons 100 101 None. This specification is written for WGL. 102 103Additions to the WGL specification 104 105 Context Creation 106 ---------------- 107 108 To create an OpenGL rendering context, call 109 110 HGLRC wglCreateContextAttribsARB(HDC hDC, HGLRC hshareContext, 111 const int *attribList); 112 113 If wglCreateContextAttribsARB succeeds, it initializes the context 114 to the initial state defined by the OpenGL specification, and 115 returns a handle to it. The handle can be used (via wglMakeCurrent 116 or wglMakeContextCurrentARB) with any HDC sharing the same pixel 117 format as <hDC>, and created on the same device, subject to 118 constraints imposed by the API version. 119 120 If <hshareContext> is not 0, then all shareable data (excluding 121 OpenGL texture objects named 0) will be shared by <hshareContext>, 122 all other contexts <hshareContext> already shares with, and the 123 newly created context. An arbitrary number of contexts can share 124 data in this fashion. 125 126 <attribList> specifies a list of attributes for the context. The 127 list consists of a sequence of <name,value> pairs terminated by the 128 value 0. If an attribute is not specified in <attribList>, then the 129 default value specified below is used instead. If an attribute is 130 specified more than once, then the last value specified is used. 131 132 <attribList> may be NULL or empty (first attribute is 0), in which 133 case all attributes assume their default values as described below. 134 135 The attribute names WGL_CONTEXT_MAJOR_VERSION_ARB and 136 WGL_CONTEXT_MINOR_VERSION_ARB request an OpenGL context supporting 137 the specified version of the API. If successful, the context 138 returned must be backwards compatible with the context requested. 139 Backwards compatibility is determined as follows: 140 141 If a version less than or equal to 3.0 is requested, the context 142 returned may implement any of the following versions: 143 144 * Any version no less than that requested and no greater than 3.0. 145 * Version 3.1, if the GL_ARB_compatibility extension is also 146 implemented. 147 * The compatibility profile of version 3.2 or greater. 148 149 If version 3.1 is requested, the context returned may implement 150 any of the following versions: 151 152 * Version 3.1. The GL_ARB_compatibility extension may or may not 153 be implemented, as determined by the implementation. 154 * The core profile of version 3.2 or greater. 155 156 If version 3.2 or greater is requested, the context returned may 157 implement any of the following versions: 158 159 * The requested profile of the requested version. 160 * The requested profile of any later version, so long as no 161 features have been removed from that later version and profile. 162 163 Querying the GL_VERSION string with glGetString (or the 164 GL_MAJOR_VERSION and GL_MINOR_VERSION values with glGetIntegerv, in 165 a 3.0 or later context) will return the actual version supported by 166 a context. 167 168 The default values for WGL_CONTEXT_MAJOR_VERSION_ARB and 169 WGL_CONTEXT_MINOR_VERSION_ARB are 1 and 0 respectively. In this 170 case, implementations will typically return the most recent version 171 of OpenGL they support which is backwards compatible with OpenGL 1.0 172 (e.g. 3.0, 3.1 + GL_ARB_compatibility, or 3.2 compatibility profile) 173 174 The attribute name WGL_CONTEXT_PROFILE_MASK_ARB requests an OpenGL 175 context supporting a specific <profile> of the API. If the 176 WGL_CONTEXT_CORE_PROFILE_BIT_ARB bit is set in the attribute value, 177 then a context implementing the <core> profile of OpenGL is 178 returned. If the WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB bit is 179 set, then a context implementing the <compatibility> profile is 180 returned. If the requested OpenGL version is less than 3.2, 181 WGL_CONTEXT_PROFILE_MASK_ARB is ignored and the functionality of the 182 context is determined solely by the requested version. 183 184 Querying the value of GL_CONTEXT_PROFILE_MASK with glGetIntegerv 185 will return the profile mask used to create the context. This query 186 is only supported in an OpenGL 3.2 or later context. 187 188 The default value for WGL_CONTEXT_PROFILE_MASK_ARB is 189 WGL_CONTEXT_CORE_PROFILE_BIT_ARB. All OpenGL 3.2 implementations are 190 required to implement the core profile, but implementation of the 191 compatibility profile is optional. 192 193 If the core profile is requested, then the context returned cannot 194 implement functionality defined only by the compatibility profile. 195 196 The attribute name WGL_CONTEXT_LAYER_PLANE specifies the layer plane 197 that the rendering context is bound to. The attribute value has the 198 same meaning and allowed values as the <iLayerPlane> parameter of 199 wglCreateLayerContext. The default value for WGL_CONTEXT_LAYER_PLANE 200 is 0 (the main plane). 201 202 The attribute name WGL_CONTEXT_FLAGS_ARB specifies a set of flag 203 bits affecting the rendering context. 204 205 If the WGL_CONTEXT_DEBUG_BIT_ARB flag bit is set in 206 WGL_CONTEXT_FLAGS_ARB, then a <debug context> will be created. Debug 207 contexts are intended for use during application development, and 208 provide additional runtime checking, validation, and logging 209 functionality while possibly incurring performance penalties. The 210 additional functionality provided by debug contexts may vary 211 according to the implementation(fn). In some cases a debug context 212 may be identical to a non-debug context. 213 [fn: The ARB Ecosystem TSG is still defining the expected and 214 required features of debug contexts.] 215 216 If the WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB is set in 217 WGL_CONTEXT_FLAGS_ARB, then a <forward-compatible> context will be 218 created. Forward-compatible contexts are defined only for OpenGL 219 versions 3.0 and later. They must not support functionality marked 220 as <deprecated> by that version of the API, while a 221 non-forward-compatible context must support all functionality in 222 that version, deprecated or not. 223 224 The default value of WGL_CONTEXT_FLAGS_ARB is 0. 225 226 On failure wglCreateContextAttribsARB returns NULL. Extended error 227 information can be obtained with GetLastError. Conditions that cause 228 failure include: 229 230 * If attributes WGL_CONTEXT_MAJOR_VERSION_ARB and 231 WGL_CONTEXT_MINOR_VERSION_ARB, when considered together with 232 WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, specify an OpenGL version 233 and feature set that are not defined, then ERROR_INVALID_VERSION_ARB 234 is generated. 235 236 The defined versions of OpenGL at the time of writing are OpenGL 237 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 2.0, 2.1, 3.0, 3.1, and 3.2. Feature 238 deprecation was introduced with OpenGL 3.0, so forward-compatible 239 contexts may only be requested for OpenGL 3.0 and above. Thus, 240 examples of invalid combinations of attributes include: 241 242 - Major version < 1 or > 3 243 - Major version == 1 and minor version < 0 or > 5 244 - Major version == 2 and minor version < 0 or > 1 245 - Major version == 3 and minor version > 2 246 - Forward-compatible flag set and major version < 3 247 248 Because the purpose of forward-compatible contexts is to allow 249 application development on a specific OpenGL version with the 250 knowledge that the app will run on a future version, context 251 creation will fail if WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB is set 252 and the context version returned cannot implement exactly the 253 requested version. 254 255 * If attribute WGL_CONTEXT_PROFILE_MASK_ARB has no bits set; has any 256 bits set other than WGL_CONTEXT_CORE_PROFILE_BIT_ARB and 257 WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; has more than one of 258 these bits set; or if the implementation does not supported the 259 requested profile, then ERROR_INVALID_PROFILE_ARB is generated. 260 261 * If <hShareContext> is neither zero nor a valid context handle, then 262 ERROR_INVALID_OPERATION is generated. 263 264 * If <hDC> is not a valid device context handle, then 265 ERROR_DC_NOT_FOUND is generated. 266 267 * If the pixel format associated with <hDC> does not support OpenGL 268 contexts providing the requested API major and minor version, 269 forward-compatible flag, and/or debug context flag, then 270 ERROR_INVALID_PIXEL_FORMAT is generated. 271 272 * If the OpenGL server context state for <hShareContext> exists in an 273 address space that cannot be shared with the newly created context, 274 if <shareContext> was created on a different device context than the 275 one referenced by <hDC>, or if the contexts are otherwise 276 incompatible (for example, one context being associated with a 277 hardware device driver and the other with a software renderer), then 278 ERROR_INVALID_OPERATION is generated. 279 280 * If the server does not have enough resources to allocate the new 281 context, then ERROR_NO_SYSTEM_RESOURCES is generated. 282 283 * If an unrecognized attribute is present in <attribList>, 284 then ERROR_INVALID_PARAMETER is generated. 285 286 Legacy Context Creation 287 ----------------------- 288 289 When this extension is supported, calling 290 291 wglCreateContext(hdc) 292 293 is equivalent to calling 294 295 wglCreateContextAttribs(hdc,0,NULL). 296 297 Calling 298 299 wglCreateLayerContext(hdc,layer) 300 301 is equivalent to calling 302 303 wglCreateContextAttribs(hdc, 0, 304 { WGL_CONTEXT_LAYER_PLANE, layer, 0 }) . 305 306 The legacy context creation routines can only return OpenGL 3.1 307 contexts if the GL_ARB_compatibility extension is supported, and can 308 only return OpenGL 3.2 or greater contexts implementing the 309 compatibility profile. This ensures compatibility for existing 310 applications. However, 3.0-aware applications are encouraged to use 311 wglCreateContextAttribsARB instead of the legacy routines. 312 313 Binding a Context to a Surface 314 ------------------------------ 315 316 (add to the description of wglMakeCurrent and 317 wglMakeContextCurrentARB) 318 319 "If the OpenGL context version of <hglrc> is 3.0 or above, and if 320 either the <hdc> parameter of wglMakeCurrent is NULL, or both of the 321 <hDrawDC> and <hReadDC> parameters of wglMakeContextCurrentARB are 322 NULL, then the context is made current, but with no default 323 framebuffer defined. The effects of having no default framebuffer on 324 the GL are defined in Chapter 4 of the OpenGL 3.0 Specification. 325 326 The first time <ctx> is made current, the viewport and scissor 327 dimensions are set to the size of the draw drawable (as though 328 glViewport(0,0,w,h) and glScissor(0,0,w,h) were called, where <w> 329 and <h> are the width and height of the drawable, respectively). If 330 the first time <ctx> is made current, it is without a default 331 framebuffer, then the viewport and scissor regions are set as though 332 glViewport(0,0,0,0) and glScissor(0,0,0,0) were called." 333 However, the viewport and scissor dimensions are not modified when 334 <ctx> is subsequently made current; it is the client's 335 responsibility to reset the viewport and scissor in this case." 336 337 Sharing Objects Between Contexts 338 -------------------------------- 339 340 (add to the description of wglShareLists) 341 342 Future versions of OpenGL may only support being added to a share 343 group at context creation time. Specifying such a version of a 344 context as either the <hglrc1> or <hglrc2> arguments to 345 wglShareLists will fail. wglShareLists will return FALSE, and 346 GetLastError will return ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB. 347 348Dependencies on WGL_ARB_extensions_string 349 350 Because there is no way to extend wgl, these calls are defined in 351 the ICD and can be called by obtaining the address with 352 wglGetProcAddress. Because this extension is a WGL extension, it is 353 not included in the GL_EXTENSIONS string. Its existence can be 354 determined with the WGL_ARB_extensions_string extension. 355 356Dependencies on WGL_ARB_create_context 357 358 If WGL_ARB_create_context_profile is supported, then 359 WGL_ARB_create_context must also be supported. 360 361Dependencies on OpenGL 3.2 and later OpenGL versions 362 363 If WGL_ARB_create_context is supported, and if the OpenGL 364 implementation supports OpenGL 3.2 or later, then 365 WGL_ARB_create_context_profile must also be supported. If the OpenGL 366 implementation does not support OpenGL 3.2 or later, then 367 WGL_ARB_create_context_profile may or may not be supported. 368 369 If WGL_ARB_create_context_profile is not supported, then the 370 WGL_CONTEXT_PROFILE_MASK_ARB attribute, the 371 WGL_CONTEXT_CORE_PROFILE_BIT_ARB and 372 WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB bits in that attribute, 373 and the ERROR_INVALID_PROFILE_ARB error are not defined, and 374 specifying the attribute in <attribList> attribute will generate an 375 error. 376 377New State 378 379 None 380 381New Implementation Dependent State 382 383 None 384 385Conformance Tests 386 387 TBD 388 389Sample Code 390 391 TBD 392 393Issues 394 395 1) Can different GL context versions share data? 396 397 PROPOSED: Yes, with restrictions as defined by the supported feature 398 sets. For example, program and shader objects cannot be shared with 399 OpenGL 1.x contexts, which do not support them. 400 401 NOTE: When the new object model is introduced, sharing must be 402 established at creation time, since the object handle namespace is 403 also shared. wglShareLists would therefore fail if either context 404 parameter to it were to be a context supporting the new object 405 model. 406 407 2) Should we introduce a token WGL_NONE to terminate attribute lists, 408 instead of using the value 0, by analogy to GLX and EGL? 409 410 RESOLVED: No. 411 412 3) Should all GL context versions be able to bind to all the same pixel 413 formats? 414 415 RESOLVED: unlike EGL, we don't expose the version restriction in the 416 pixel format. Instead, wglMakeCurrent may fail when binding contexts 417 to surfaces if the surface type is unrecognized by that context 418 version. No specific examples exist at present, but in a 419 hypothetical future version of the API supporting only the new 420 object model, such an API probably could not bind to pbuffer 421 surfaces. 422 423 4) Should there be a way to make a context current without binding 424 it to a window system drawable at the same time? 425 426 RESOLVED: Yes, but only in OpenGL 3.0 and later. This results in a 427 context with an invalid default framebuffer, the meaning of which is 428 defined in the OpenGL 3.0 specification. 429 430 NOTE: Apparently on Windows, opengl32.dll makes use of the drawable 431 argument to identify the namespace of the driver, so we may not be 432 able to work around it. 433 434 5) Should we add a token to the attrib list for pixel format selection 435 to indicate the GL context version, instead of introducing a new 436 entry point for context creation? 437 438 RESOLVED: No. We want pixel formats to be portable between 439 feature-incompatible context versions, so that drawables and GL 440 objects that make sense to share, may be shared between such 441 contexts. This is important for code migration and backward 442 compatibility. 443 444 6) Do we need a "can be shared" parameter at context creation time? 445 446 RESOLVED: No. All contexts have potential to share objects (whether 447 they actually can share depends on context version and feature sets, 448 and the address space they're created in). Savings from saying a 449 context cannot share objects are unclear but probably minimal. Such 450 a parameter would default to TRUE if it existed. 451 452 7) How are "debug contexts" created? 453 454 RESOLVED: by specifying the WGL_CONTEXT_DEBUG_BIT_ARB flag in the 455 WGL_CONTEXT_FLAGS_ARB attribute value. 456 457 DISCUSSION: For the most part, the behavior of debug contexts is 458 being determined by the ARB Ecosystem TSG. However, whatever their 459 behavior, it's clear that "debug contexts" may differ at a basic 460 level from regular contexts. Debug contexts might even go down a 461 completely separate driver path. So it's essential to know at 462 context creation time if a debug context is required. 463 464 8) Is wglCreateContextVersion a good name? 465 466 Ian Romanick suggests wglCreateContextAttribs instead. Changed in 467 version 12. 468 469 9) Should the context version be named with separate major and minor 470 number attributes, or as a single (major*100 + minor*10) number as 471 in GLSL (e.g. version == 220 <-> major = 2, minor = 2)? 472 473 John Kessenich argues for consistency with the existing GLSL naming 474 scheme. 475 47610) How are profiles specified? Why is the profile attribute a bitmask 477 rather than an enum? 478 479 RESOLVED: Profiles are specified as individual bits passed in a 480 bitmask attribute. This attribute is ignored unless the OpenGL 481 version requested defines profiles (OpenGL 3.2 and later). While 482 only a single profile can be specified today, it is not unlikely 483 that eventually there will be profiles defined than can be 484 implemented in the same context. In that case we will need to be 485 able to specify multiple profiles at context creation and in the GL 486 context profile query, for which a bitmask is appropriate. 487 48811) Why is the value of WGL_CONTEXT_PROFILE_MASK_ARB in the GL 489 core enumerant range? 490 491 RESOLVED: The token value for the context profile mask and for the 492 context profile bits should be shared by GL, GLX, and WGL to ease 493 implementation and reduce programming errors. These values are drawn 494 from the GL token ranges. 495 49612) What errors can result from requesting a profile? 497 498 RESOLVED: Only a single profile can currently be requested. 499 Requesting no profile, more than one profile, or an unrecognized 500 profile are all errors. 501 50213) How does the profile request interact with older GL versions? 503 504 RESOLVED: It does not. The profile mask is ignored unless the 505 requested GL version is >= 3.2. 506 507 DISCUSSION: Bruce had proposed using the profile mask to control 508 whether or not GL_ARB_compatibility was provided in earlier GL 509 versions, but general feeling was that apps had already had to sort 510 this out, and it's difficult to see how to define a default value 511 that can always be implemented (core profile) without changing the 512 existing behavior of wglCreateContextAttribsARB on implementations 513 which implement GL_ARB_compatibility by default when an OpenGL 3.1 514 context is requested. 515 51614) How does the profile request interact with the forward compatibility 517 bit? 518 519 RESOLVED: Nothing special need be done here. If the forward 520 compatibility bit is set, the returned context must not implement 521 deprecated functionality in that profile (nothing is deprecated 522 from the OpenGL 3.2 compatibility profile, so a forward-compatible 523 compatibility profile has exactly the same functionality as 524 a non-forward-compatible compatibility profile, while a 525 forward-compatible core profile would leave out only the handful 526 of features - wide lines and two queries - deprecated from core 527 OpenGL 3.2). 528 52915) How is context sharing between contexts of different versions 530 handled? 531 532 RESOLVED: It's up to the implementation whether or not to allow 533 this, and to define behavior when shared objects include state or 534 behaviors not described by one of the contexts sharing them (for 535 example, textures with nonzero width borders shared by 3.2 core and 536 compatibility profile contexts). 537 53816) Is the GL_ARB_compatibility extension equivalent to the 539 compatibility profile? 540 541 RESOLVED: No. The extension refers specifically to functionality 542 removed from OpenGL 3.1 and restored by this extension. The 543 compatibility profile also restores this functionality, but may 544 define additional interactions between new features in version 3.N 545 and the functionality removed in OpenGL 3.1. 546 547 In other words, the extension is a subset of the compatibility 548 profile. A context implementing the compatibility profile for OpenGL 549 3.2 or greater may (and probably will) choose to export 550 GL_ARB_compatibility, but this is not required. 551 55217) If the core profile is requested, what additional functionality 553 can be provided? 554 555 RESOLVED: Functionality defined only by the compatibility profile 556 cannot be implemented by a context supporting the core profile. For 557 example, if a 3.2 core profile is requested, that context cannot 558 implement the GL_ARB_compatibility extension. However, any desired 559 new functionality may be exposed via vendor or ARB extensions in the 560 normal fashion. 561 562 563Revision History 564 565 Version 20, 2009/07/28 - Correct issue 14 to note that the 3.2 566 compatibility profile does not deprecated anything. 567 568 Version 19, 2009/07/27 - Add profiled context creation functionality 569 (WGL_CONTEXT_PROFILE_MASK_ARB and the associated bit tokens, error 570 code, and issues 10-16). Clarify that if the core profile is 571 requested, the returned context cannot restore functionality from 572 the compatibility profile (issue 17 and corresponding spec 573 language). Add ERROR_INVALID_PARAMETER error if an unrecognized 574 attribute is specified. Specify the interdependencies between the 575 two WGL extensions defined here and OpenGL 3.2, including the 576 requirement that WGL_ARB_create_context_profile be supported if an 577 OpenGL 3.2 or later implementation is supported. 578 579 Version 18, 2009/07/24 - Specify that repeated attribute values 580 always result in the last specified value being used. 581 582 Version 17, 2009/07/23 - Update the extension to clarify 583 interactions with OpenGL 3.1 and greater, allow returning 3.0 and 584 greater contexts from the legacy context creation routines so long 585 as they're backwards compatible, and mandate that requesting a 586 forward-compatible context always return exactly the requested 587 version (bugs 5112, 5349). 588 589 Version 16, 2008/08/21 - Add initial viewport/scissor setting 590 behavior (cloned from GLX, including the case when no default 591 framebuffer is made current. 592 593 Version 15, 2008/08/10 - Assign enumerant values and extension 594 number. 595 596 Version 14, 2008/07/10 - Add trailing zero to array attributes in 597 wglCreateLayerContext example (Pat Brown). 598 599 Version 13, 2008/07/03 - Update versioning behavior so asking for <= 600 2.1 will return <= 2.1, asking for 3.0 will return 3.0, and noting 601 that we must update interactions with GL once 3.1 is defined. 602 Mandated behavior of legacy context creation APIs when this 603 extension is supported (bug 3595). 604 605 Version 12, 2008/07/02 - Rename WGL_PREVIEW_BIT to 606 WGL_CONTEXT_FORWARD_COMPATIBLE_BIT and other replace "preview 607 context" with "forward-compatible context". Rename 608 wglCreateContextVersion to wglCreateContextAttribs. 609 610 Version 11, 2008/06/12 - Use ARB suffix. Raise ERROR_INVALID_VERSION 611 instead of ERROR_INVALID_DATA on a bad version/preview combination. 612 613 Version 10, 2008/04/08 - Changed "lite" to "preview" (still open for 614 discussion however), and changed version "2.2" to "3.0" following 615 the marketing TSG recommendation. Changed definition of preview 616 contexts so that deprecated functionality *must not* be supported. 617 Added issue 10 about how to handle profiles. 618 619 Version 9, 2008/02/07 - Added version naming issue 9. 620 621 Version 8, 2008/02/07 - Added naming issue 8. Removed reference to 622 GL version 3 in "Sharing Objects Between Contexts". 623 624 Version 7, 2008/02/01 - Rewrote issues list in light of new API 625 direction, and reopened some issues. Added separate major and minor 626 version attributes and "lite" API flag. 627 628 Version 6, 2007/05/22 - Resolve issue 4, although the exact 629 mechanism is still unknown. 630 631 Version 5, 2007/04/09 - Added WGL_CONTEXT_FLAGS attribute and 632 WGL_CONTEXT_DEBUG_BIT flag, and a high-level description of the 633 concept of "debug contexts". 634 635 Version 4, 2007/02/06 - Removed CreateContextVersion error when GL2 636 and Longs Peak contexts are placed in the same share group, and 637 referred to the GL_EXT_bind_image extension in issue 1. Added issues 638 6 ("can be shared" attribute) and 7 (creation of debug contexts) per 639 discussion at the Atlanta F2F ARB meeting. Added error condition for 640 wglShareLists if passed a Longs Peak context handle. 641 642 Version 3, 2007/01/22 - added issue 5. 643 644 Version 2, 2007/01/17 - change to the same style as 645 eglCreateContext, using an attribute list. Add wglMakeCurrent 646 language disallowing current 3.x contexts bound to pbuffers, and 647 allowing current 3.x context without a window-system provided 648 framebuffer. 649 650 Version 1, 2007/1/17 - First draft 651