blob: 3f8762356680284e84749cd3f9c963a14344d066 [file] [log] [blame]
Name Strings
Jon Leech (jon 'at'
Michael Gold, NVIDIA (gold 'at'
Copyright (c) 2009-2013 The Khronos Group Inc. Copyright terms at
Specification Update Policy
Khronos-approved extension specifications are updated in response to
issues and bugs prioritized by the Khronos OpenGL Working Group. For
extensions which have been promoted to a core Specification, fixes will
first appear in the latest version of that core Specification, and will
eventually be backported to the extension document. This policy is
described in more detail at
IP Status
No known IP claims.
Complete. Approved by the ARB on July 28, 2009.
Approved by the Khronos Board of Promoters on August 28, 2009.
July 28, 2009 (version 20)
ARB Extension #55 (WGL_ARB_create_context)
ARB Extension #74 (WGL_ARB_create_context_profile)
WGL_ARB_extensions_string is required.
The presence of an OpenGL 3.2 or later implementation determines
whether or not WGL_ARB_create_context_profile is required.
With the advent of new versions of OpenGL which deprecate features
and/or break backward compatibility with older versions, there is a
need and desire to indicate at context creation which interface will
be used. These extensions add a new context creation routine with
attributes specifying the GL version and context properties
requested for the context, and additionally add an attribute
specifying the GL profile requested for a context of OpenGL 3.2 or
New Procedures and Functions
HGLRC wglCreateContextAttribsARB(HDC hDC, HGLRC hShareContext,
const int *attribList)
New Tokens
Accepted as an attribute name in <*attribList>:
Accepted as bits in the attribute value for WGL_CONTEXT_FLAGS in
Accepted as bits in the attribute value for
New errors returned by GetLastError:
Additions to the OpenGL / GLX / GLX Protocol Specificaitons
None. This specification is written for WGL.
Additions to the WGL specification
Context Creation
To create an OpenGL rendering context, call
HGLRC wglCreateContextAttribsARB(HDC hDC, HGLRC hshareContext,
const int *attribList);
If wglCreateContextAttribsARB succeeds, it initializes the context
to the initial state defined by the OpenGL specification, and
returns a handle to it. The handle can be used (via wglMakeCurrent
or wglMakeContextCurrentARB) with any HDC sharing the same pixel
format as <hDC>, and created on the same device, subject to
constraints imposed by the API version.
If <hshareContext> is not 0, then all shareable data (excluding
OpenGL texture objects named 0) will be shared by <hshareContext>,
all other contexts <hshareContext> already shares with, and the
newly created context. An arbitrary number of contexts can share
data in this fashion.
<attribList> specifies a list of attributes for the context. The
list consists of a sequence of <name,value> pairs terminated by the
value 0. If an attribute is not specified in <attribList>, then the
default value specified below is used instead. If an attribute is
specified more than once, then the last value specified is used.
<attribList> may be NULL or empty (first attribute is 0), in which
case all attributes assume their default values as described below.
The attribute names WGL_CONTEXT_MAJOR_VERSION_ARB and
WGL_CONTEXT_MINOR_VERSION_ARB request an OpenGL context supporting
the specified version of the API. If successful, the context
returned must be backwards compatible with the context requested.
Backwards compatibility is determined as follows:
If a version less than or equal to 3.0 is requested, the context
returned may implement any of the following versions:
* Any version no less than that requested and no greater than 3.0.
* Version 3.1, if the GL_ARB_compatibility extension is also
* The compatibility profile of version 3.2 or greater.
If version 3.1 is requested, the context returned may implement
any of the following versions:
* Version 3.1. The GL_ARB_compatibility extension may or may not
be implemented, as determined by the implementation.
* The core profile of version 3.2 or greater.
If version 3.2 or greater is requested, the context returned may
implement any of the following versions:
* The requested profile of the requested version.
* The requested profile of any later version, so long as no
features have been removed from that later version and profile.
Querying the GL_VERSION string with glGetString (or the
GL_MAJOR_VERSION and GL_MINOR_VERSION values with glGetIntegerv, in
a 3.0 or later context) will return the actual version supported by
a context.
The default values for WGL_CONTEXT_MAJOR_VERSION_ARB and
WGL_CONTEXT_MINOR_VERSION_ARB are 1 and 0 respectively. In this
case, implementations will typically return the most recent version
of OpenGL they support which is backwards compatible with OpenGL 1.0
(e.g. 3.0, 3.1 + GL_ARB_compatibility, or 3.2 compatibility profile)
The attribute name WGL_CONTEXT_PROFILE_MASK_ARB requests an OpenGL
context supporting a specific <profile> of the API. If the
WGL_CONTEXT_CORE_PROFILE_BIT_ARB bit is set in the attribute value,
then a context implementing the <core> profile of OpenGL is
set, then a context implementing the <compatibility> profile is
returned. If the requested OpenGL version is less than 3.2,
WGL_CONTEXT_PROFILE_MASK_ARB is ignored and the functionality of the
context is determined solely by the requested version.
Querying the value of GL_CONTEXT_PROFILE_MASK with glGetIntegerv
will return the profile mask used to create the context. This query
is only supported in an OpenGL 3.2 or later context.
The default value for WGL_CONTEXT_PROFILE_MASK_ARB is
WGL_CONTEXT_CORE_PROFILE_BIT_ARB. All OpenGL 3.2 implementations are
required to implement the core profile, but implementation of the
compatibility profile is optional.
If the core profile is requested, then the context returned cannot
implement functionality defined only by the compatibility profile.
The attribute name WGL_CONTEXT_LAYER_PLANE specifies the layer plane
that the rendering context is bound to. The attribute value has the
same meaning and allowed values as the <iLayerPlane> parameter of
wglCreateLayerContext. The default value for WGL_CONTEXT_LAYER_PLANE
is 0 (the main plane).
The attribute name WGL_CONTEXT_FLAGS_ARB specifies a set of flag
bits affecting the rendering context.
If the WGL_CONTEXT_DEBUG_BIT_ARB flag bit is set in
WGL_CONTEXT_FLAGS_ARB, then a <debug context> will be created. Debug
contexts are intended for use during application development, and
provide additional runtime checking, validation, and logging
functionality while possibly incurring performance penalties. The
additional functionality provided by debug contexts may vary
according to the implementation(fn). In some cases a debug context
may be identical to a non-debug context.
[fn: The ARB Ecosystem TSG is still defining the expected and
required features of debug contexts.]
WGL_CONTEXT_FLAGS_ARB, then a <forward-compatible> context will be
created. Forward-compatible contexts are defined only for OpenGL
versions 3.0 and later. They must not support functionality marked
as <deprecated> by that version of the API, while a
non-forward-compatible context must support all functionality in
that version, deprecated or not.
The default value of WGL_CONTEXT_FLAGS_ARB is 0.
On failure wglCreateContextAttribsARB returns NULL. Extended error
information can be obtained with GetLastError. Conditions that cause
failure include:
WGL_CONTEXT_MINOR_VERSION_ARB, when considered together with
and feature set that are not defined, then ERROR_INVALID_VERSION_ARB
is generated.
The defined versions of OpenGL at the time of writing are OpenGL
1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 2.0, 2.1, 3.0, 3.1, and 3.2. Feature
deprecation was introduced with OpenGL 3.0, so forward-compatible
contexts may only be requested for OpenGL 3.0 and above. Thus,
examples of invalid combinations of attributes include:
- Major version < 1 or > 3
- Major version == 1 and minor version < 0 or > 5
- Major version == 2 and minor version < 0 or > 1
- Major version == 3 and minor version > 2
- Forward-compatible flag set and major version < 3
Because the purpose of forward-compatible contexts is to allow
application development on a specific OpenGL version with the
knowledge that the app will run on a future version, context
creation will fail if WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB is set
and the context version returned cannot implement exactly the
requested version.
* If attribute WGL_CONTEXT_PROFILE_MASK_ARB has no bits set; has any
bits set other than WGL_CONTEXT_CORE_PROFILE_BIT_ARB and
these bits set; or if the implementation does not supported the
requested profile, then ERROR_INVALID_PROFILE_ARB is generated.
* If <hShareContext> is neither zero nor a valid context handle, then
* If <hDC> is not a valid device context handle, then
ERROR_DC_NOT_FOUND is generated.
* If the pixel format associated with <hDC> does not support OpenGL
contexts providing the requested API major and minor version,
forward-compatible flag, and/or debug context flag, then
* If the OpenGL server context state for <hShareContext> exists in an
address space that cannot be shared with the newly created context,
if <shareContext> was created on a different device context than the
one referenced by <hDC>, or if the contexts are otherwise
incompatible (for example, one context being associated with a
hardware device driver and the other with a software renderer), then
* If the server does not have enough resources to allocate the new
context, then ERROR_NO_SYSTEM_RESOURCES is generated.
* If an unrecognized attribute is present in <attribList>,
then ERROR_INVALID_PARAMETER is generated.
Legacy Context Creation
When this extension is supported, calling
is equivalent to calling
is equivalent to calling
wglCreateContextAttribs(hdc, 0,
{ WGL_CONTEXT_LAYER_PLANE, layer, 0 }) .
The legacy context creation routines can only return OpenGL 3.1
contexts if the GL_ARB_compatibility extension is supported, and can
only return OpenGL 3.2 or greater contexts implementing the
compatibility profile. This ensures compatibility for existing
applications. However, 3.0-aware applications are encouraged to use
wglCreateContextAttribsARB instead of the legacy routines.
Binding a Context to a Surface
(add to the description of wglMakeCurrent and
"If the OpenGL context version of <hglrc> is 3.0 or above, and if
either the <hdc> parameter of wglMakeCurrent is NULL, or both of the
<hDrawDC> and <hReadDC> parameters of wglMakeContextCurrentARB are
NULL, then the context is made current, but with no default
framebuffer defined. The effects of having no default framebuffer on
the GL are defined in Chapter 4 of the OpenGL 3.0 Specification.
The first time <ctx> is made current, the viewport and scissor
dimensions are set to the size of the draw drawable (as though
glViewport(0,0,w,h) and glScissor(0,0,w,h) were called, where <w>
and <h> are the width and height of the drawable, respectively). If
the first time <ctx> is made current, it is without a default
framebuffer, then the viewport and scissor regions are set as though
glViewport(0,0,0,0) and glScissor(0,0,0,0) were called."
However, the viewport and scissor dimensions are not modified when
<ctx> is subsequently made current; it is the client's
responsibility to reset the viewport and scissor in this case."
Sharing Objects Between Contexts
(add to the description of wglShareLists)
Future versions of OpenGL may only support being added to a share
group at context creation time. Specifying such a version of a
context as either the <hglrc1> or <hglrc2> arguments to
wglShareLists will fail. wglShareLists will return FALSE, and
Dependencies on WGL_ARB_extensions_string
Because there is no way to extend wgl, these calls are defined in
the ICD and can be called by obtaining the address with
wglGetProcAddress. Because this extension is a WGL extension, it is
not included in the GL_EXTENSIONS string. Its existence can be
determined with the WGL_ARB_extensions_string extension.
Dependencies on WGL_ARB_create_context
If WGL_ARB_create_context_profile is supported, then
WGL_ARB_create_context must also be supported.
Dependencies on OpenGL 3.2 and later OpenGL versions
If WGL_ARB_create_context is supported, and if the OpenGL
implementation supports OpenGL 3.2 or later, then
WGL_ARB_create_context_profile must also be supported. If the OpenGL
implementation does not support OpenGL 3.2 or later, then
WGL_ARB_create_context_profile may or may not be supported.
If WGL_ARB_create_context_profile is not supported, then the
and the ERROR_INVALID_PROFILE_ARB error are not defined, and
specifying the attribute in <attribList> attribute will generate an
New State
New Implementation Dependent State
Conformance Tests
Sample Code
1) Can different GL context versions share data?
PROPOSED: Yes, with restrictions as defined by the supported feature
sets. For example, program and shader objects cannot be shared with
OpenGL 1.x contexts, which do not support them.
NOTE: When the new object model is introduced, sharing must be
established at creation time, since the object handle namespace is
also shared. wglShareLists would therefore fail if either context
parameter to it were to be a context supporting the new object
2) Should we introduce a token WGL_NONE to terminate attribute lists,
instead of using the value 0, by analogy to GLX and EGL?
3) Should all GL context versions be able to bind to all the same pixel
RESOLVED: unlike EGL, we don't expose the version restriction in the
pixel format. Instead, wglMakeCurrent may fail when binding contexts
to surfaces if the surface type is unrecognized by that context
version. No specific examples exist at present, but in a
hypothetical future version of the API supporting only the new
object model, such an API probably could not bind to pbuffer
4) Should there be a way to make a context current without binding
it to a window system drawable at the same time?
RESOLVED: Yes, but only in OpenGL 3.0 and later. This results in a
context with an invalid default framebuffer, the meaning of which is
defined in the OpenGL 3.0 specification.
NOTE: Apparently on Windows, opengl32.dll makes use of the drawable
argument to identify the namespace of the driver, so we may not be
able to work around it.
5) Should we add a token to the attrib list for pixel format selection
to indicate the GL context version, instead of introducing a new
entry point for context creation?
RESOLVED: No. We want pixel formats to be portable between
feature-incompatible context versions, so that drawables and GL
objects that make sense to share, may be shared between such
contexts. This is important for code migration and backward
6) Do we need a "can be shared" parameter at context creation time?
RESOLVED: No. All contexts have potential to share objects (whether
they actually can share depends on context version and feature sets,
and the address space they're created in). Savings from saying a
context cannot share objects are unclear but probably minimal. Such
a parameter would default to TRUE if it existed.
7) How are "debug contexts" created?
RESOLVED: by specifying the WGL_CONTEXT_DEBUG_BIT_ARB flag in the
WGL_CONTEXT_FLAGS_ARB attribute value.
DISCUSSION: For the most part, the behavior of debug contexts is
being determined by the ARB Ecosystem TSG. However, whatever their
behavior, it's clear that "debug contexts" may differ at a basic
level from regular contexts. Debug contexts might even go down a
completely separate driver path. So it's essential to know at
context creation time if a debug context is required.
8) Is wglCreateContextVersion a good name?
Ian Romanick suggests wglCreateContextAttribs instead. Changed in
version 12.
9) Should the context version be named with separate major and minor
number attributes, or as a single (major*100 + minor*10) number as
in GLSL (e.g. version == 220 <-> major = 2, minor = 2)?
John Kessenich argues for consistency with the existing GLSL naming
10) How are profiles specified? Why is the profile attribute a bitmask
rather than an enum?
RESOLVED: Profiles are specified as individual bits passed in a
bitmask attribute. This attribute is ignored unless the OpenGL
version requested defines profiles (OpenGL 3.2 and later). While
only a single profile can be specified today, it is not unlikely
that eventually there will be profiles defined than can be
implemented in the same context. In that case we will need to be
able to specify multiple profiles at context creation and in the GL
context profile query, for which a bitmask is appropriate.
11) Why is the value of WGL_CONTEXT_PROFILE_MASK_ARB in the GL
core enumerant range?
RESOLVED: The token value for the context profile mask and for the
context profile bits should be shared by GL, GLX, and WGL to ease
implementation and reduce programming errors. These values are drawn
from the GL token ranges.
12) What errors can result from requesting a profile?
RESOLVED: Only a single profile can currently be requested.
Requesting no profile, more than one profile, or an unrecognized
profile are all errors.
13) How does the profile request interact with older GL versions?
RESOLVED: It does not. The profile mask is ignored unless the
requested GL version is >= 3.2.
DISCUSSION: Bruce had proposed using the profile mask to control
whether or not GL_ARB_compatibility was provided in earlier GL
versions, but general feeling was that apps had already had to sort
this out, and it's difficult to see how to define a default value
that can always be implemented (core profile) without changing the
existing behavior of wglCreateContextAttribsARB on implementations
which implement GL_ARB_compatibility by default when an OpenGL 3.1
context is requested.
14) How does the profile request interact with the forward compatibility
RESOLVED: Nothing special need be done here. If the forward
compatibility bit is set, the returned context must not implement
deprecated functionality in that profile (nothing is deprecated
from the OpenGL 3.2 compatibility profile, so a forward-compatible
compatibility profile has exactly the same functionality as
a non-forward-compatible compatibility profile, while a
forward-compatible core profile would leave out only the handful
of features - wide lines and two queries - deprecated from core
OpenGL 3.2).
15) How is context sharing between contexts of different versions
RESOLVED: It's up to the implementation whether or not to allow
this, and to define behavior when shared objects include state or
behaviors not described by one of the contexts sharing them (for
example, textures with nonzero width borders shared by 3.2 core and
compatibility profile contexts).
16) Is the GL_ARB_compatibility extension equivalent to the
compatibility profile?
RESOLVED: No. The extension refers specifically to functionality
removed from OpenGL 3.1 and restored by this extension. The
compatibility profile also restores this functionality, but may
define additional interactions between new features in version 3.N
and the functionality removed in OpenGL 3.1.
In other words, the extension is a subset of the compatibility
profile. A context implementing the compatibility profile for OpenGL
3.2 or greater may (and probably will) choose to export
GL_ARB_compatibility, but this is not required.
17) If the core profile is requested, what additional functionality
can be provided?
RESOLVED: Functionality defined only by the compatibility profile
cannot be implemented by a context supporting the core profile. For
example, if a 3.2 core profile is requested, that context cannot
implement the GL_ARB_compatibility extension. However, any desired
new functionality may be exposed via vendor or ARB extensions in the
normal fashion.
Revision History
Version 20, 2009/07/28 - Correct issue 14 to note that the 3.2
compatibility profile does not deprecated anything.
Version 19, 2009/07/27 - Add profiled context creation functionality
(WGL_CONTEXT_PROFILE_MASK_ARB and the associated bit tokens, error
code, and issues 10-16). Clarify that if the core profile is
requested, the returned context cannot restore functionality from
the compatibility profile (issue 17 and corresponding spec
language). Add ERROR_INVALID_PARAMETER error if an unrecognized
attribute is specified. Specify the interdependencies between the
two WGL extensions defined here and OpenGL 3.2, including the
requirement that WGL_ARB_create_context_profile be supported if an
OpenGL 3.2 or later implementation is supported.
Version 18, 2009/07/24 - Specify that repeated attribute values
always result in the last specified value being used.
Version 17, 2009/07/23 - Update the extension to clarify
interactions with OpenGL 3.1 and greater, allow returning 3.0 and
greater contexts from the legacy context creation routines so long
as they're backwards compatible, and mandate that requesting a
forward-compatible context always return exactly the requested
version (bugs 5112, 5349).
Version 16, 2008/08/21 - Add initial viewport/scissor setting
behavior (cloned from GLX, including the case when no default
framebuffer is made current.
Version 15, 2008/08/10 - Assign enumerant values and extension
Version 14, 2008/07/10 - Add trailing zero to array attributes in
wglCreateLayerContext example (Pat Brown).
Version 13, 2008/07/03 - Update versioning behavior so asking for <=
2.1 will return <= 2.1, asking for 3.0 will return 3.0, and noting
that we must update interactions with GL once 3.1 is defined.
Mandated behavior of legacy context creation APIs when this
extension is supported (bug 3595).
Version 12, 2008/07/02 - Rename WGL_PREVIEW_BIT to
WGL_CONTEXT_FORWARD_COMPATIBLE_BIT and other replace "preview
context" with "forward-compatible context". Rename
wglCreateContextVersion to wglCreateContextAttribs.
Version 11, 2008/06/12 - Use ARB suffix. Raise ERROR_INVALID_VERSION
instead of ERROR_INVALID_DATA on a bad version/preview combination.
Version 10, 2008/04/08 - Changed "lite" to "preview" (still open for
discussion however), and changed version "2.2" to "3.0" following
the marketing TSG recommendation. Changed definition of preview
contexts so that deprecated functionality *must not* be supported.
Added issue 10 about how to handle profiles.
Version 9, 2008/02/07 - Added version naming issue 9.
Version 8, 2008/02/07 - Added naming issue 8. Removed reference to
GL version 3 in "Sharing Objects Between Contexts".
Version 7, 2008/02/01 - Rewrote issues list in light of new API
direction, and reopened some issues. Added separate major and minor
version attributes and "lite" API flag.
Version 6, 2007/05/22 - Resolve issue 4, although the exact
mechanism is still unknown.
Version 5, 2007/04/09 - Added WGL_CONTEXT_FLAGS attribute and
WGL_CONTEXT_DEBUG_BIT flag, and a high-level description of the
concept of "debug contexts".
Version 4, 2007/02/06 - Removed CreateContextVersion error when GL2
and Longs Peak contexts are placed in the same share group, and
referred to the GL_EXT_bind_image extension in issue 1. Added issues
6 ("can be shared" attribute) and 7 (creation of debug contexts) per
discussion at the Atlanta F2F ARB meeting. Added error condition for
wglShareLists if passed a Longs Peak context handle.
Version 3, 2007/01/22 - added issue 5.
Version 2, 2007/01/17 - change to the same style as
eglCreateContext, using an attribute list. Add wglMakeCurrent
language disallowing current 3.x contexts bound to pbuffers, and
allowing current 3.x context without a window-system provided
Version 1, 2007/1/17 - First draft