fbconfig
Specification
Name
SGIX_fbconfig
Name Strings
GLX_SGIX_fbconfig
Version
$Date: 1996/09/09 00:59:13 $ $Revision: 1.2 $
Number
49
Dependencies
SGIS_multisample affects the definition of this extension
EXT_visual_info affects the definition of this extension
EXT_visual_rating affects the definition of this extension
EXT_import_context affects the definition of this extension
SGIX_pbuffer affects the definition of this extension
Overview
This extension introduces a new way to describe the capabilities of a
GLX drawable (i.e., to describe the depth of color buffer components
and the type and size of ancillary buffers), removes the "similarity"
requirement when making a context current to a drawable, and supports
RGBA rendering to one- and two-component Windows and GLX Pixmaps.
Currently GLX overloads X Visuals with information on GLX drawable
capabilities. This extension defines a new construct, a GLXFBConfigSGIX,
that encapsulates GLX drawable capabilities and has the following
properties:
- It may or may not have an associated X visual. If it does have
an associated X visual then it is possible to create Windows that
have the capabilities described by the GLXFBConfig.
- A particular GLXFBConfig does not need to work with all GLX
drawables. For example, it is possible for implementations to export
GLXFBConfigs that only work with GLX pixmaps.
This extension also removes the "similarity" restriction when making
a context and drawable current. Instead a less restrictive requirement
of "compatibility" (see definition below) is imposed. Note that when
a context is created it has an associated rendering type which
is either RGBA or color index. In the future we may want to remove all
"similarity" and "compatibility" restrictions and allow a context to be
bound to any drawable that supports its rendering type.
Finally the current GLX specification requires that the GLX_RGBA visual
attribute be associated only with X visual types TrueColor and DirectColor.
This extension defines the semantics for doing RGBA rendering to Windows
created with visuals of type PseudoColor, StaticColor, GrayScale, and
StaticGray. In each of these cases, the red component is used to
generate the display, and the green and blue components, if present,
are ignored for display purposes.
The OpenGL RGBA rendering semantics are more powerful than the OpenGL
index rendering semantics. By extending the number of X visual types
that can be associated with an RGBA color buffer, this extension allows
RGBA rendering semantics to be used with pseudo color and gray scale
displays. An especially useful application of this extension is
support of one- and two-component RGBA drawables; drawables whose green,
blue, and sometimes alpha components have no bitplanes.
Issues
* Should GLXFBConfigs apply to all GLX drawables or just GLXPbuffers?
A: For consistency, all GLX drawables should be supported. (And if this
extension is incorporated in a future release of GLX then the existing
calls that rely on XVisualInfo structures should be deprecated.) The
current mechanism which ties the description of GLX drawables to
X visuals is inadequate since it restricts all drawable configurations
to those which can be supported by on-screen windows.
* Should the selection of an FBConfig differ from glXChooseVisual? If
so, how?
Yes. For some attributes, the default value (that is, the value that is
used if the attribute is not specified in the list) should be "don't
care". Also, an ordered list of GLXFBConfigs should be returned so
applications can go through the list and apply their own policies to
determine the best GLXFBConfig.
* Do we want to introduce the notion of "compatible" GLXFBConfigs and
visuals? (GLX currently uses the term "similar". GLXContexts and
GLXDrawables are similar iff they have been created with respect
to the same VisualID and root window.)
A: Yes. The GLX definition of similar visuals is too restrictive
(and the glXMakeCurrentRead extension already relaxes it.) This
is the right time to agree on a definition since we need to define
how GLXFBConfigs match up to X Visuals. Note, that we do not
redefine similar; instead a new term, compatible, is introduced.
In the future, we may want to remove this restriction and allow
a context to be bound to any drawable. (But a context would still
be created to do either RGBA or color index rendering.)
New Procedures and Functions
int glXGetFBConfigAttribSGIX(Display *dpy,
GLXFBConfigSGIX config,
int attribute,
int *value);
GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *dpy,
int screen,
const int *attrib_list,
int *nelements);
GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy,
GLXFBConfig config,
Pixmap pixmap);
GLXContext glXCreateContextWithConfigSGIX(Display *dpy,
GLXFBConfig config,
int render_type,
GLXContext share_list,
Bool direct);
XVisualInfo *glXGetVisualFromFBConfigSGIX(Display *dpy,
GLXFBConfig config);
GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy,
XVisualInfo *vis);
New Tokens
Accepted by the < attribute > parameter of glXGetFBConfigAttribSGIX, and
by the < attrib_list > parameter of glXChooseFBConfigSGIX:
GLX_DRAWABLE_TYPE_SGIX 0x8010
GLX_RENDER_TYPE_SGIX 0x801 GLX_X_RENDERABLE_SGIX 0x801
Accepted by the < attribute > parameter of glXGetFBConfigAttribSGIX, the
< attrib_list > parameter of glXChooseFBConfigSGIX, by the < attribute >
parameter of glXQueryGLXPbufferSGIX and by the < attribute > parameter
of glXQueryContextInfoEXT:
GLX_FBCONFIG_ID_SGIX 0x801
Accepted by the < attribute > parameter of glXGetFBConfigAttribSGIX:
GLX_SCREEN_EXT 0x800C
Returned by glXGetFBConfigAttribSGIX (when < attribute > is set to
GLX_DRAWABLE_TYPE_SGIX) and accepted by the < attrib_list > parameter of
glXChooseFBConfigSGIX (following the GLX_DRAWABLE_TYPE_SGIX token):
GLX_WINDOW_BIT_SGIX 0x0000000
GLX_PIXMAP_BIT_SGIX 0x0000000
Returned by glXGetFBConfigAttribSGIX (when < attribute > is set to
GLX_RENDER_TYPE_SGIX) and accepted by the < attrib_list > parameter of
glXChooseFBConfigSGIX (following the GLX_RENDER_TYPE_SGIX token):
GLX_RGBA_BIT_SGIX 0x0000000
GLX_COLOR_INDEX_BIT_SGIX 0x0000000
Accepted by the < render_type > parameter of glXCreateContextWithConfigSGIX:
GLX_RGBA_TYPE_SGIX 0x8014
GLX_COLOR_INDEX_TYPE_SGIX 0x8015
Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation)
None
Additions to Chapter 3 of the 1.0 Specification (Rasterization)
None
Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations
and the Frame buffer)
In section 4.1.6 (Blending) follow the sentence "If a color buffer has
no A value, then it is as if the destination A value is 1." with the
sentence "If the color buffer has no R, G, or B value, then it is as
if the destination R, G, or B value is 0."
In section 4.3.2 (Reading Pixels) follow the sentence "If the framebuffer
does not support alpha values then the A that is obtained is 1.0." with
the sentence "If the framebuffer does not support red, green, or blue
values, then the R, G or B that is obtained is 0.0."
Additions to Chapter 5 of the 1.0 Specification (Special Functions)
None
Additions to Chapter 6 of the 1.0 Specification (State and State Requests)
None
Additions to the GLX Specification
[Add the following to section 3.2.2 on Configuration Management]
A GLXFBConfigSGIX describes the format, type and size of the color
buffers and ancillary buffers for a GLXDrawable. When the GLXDrawable
is a window then the GLXFBConfigSGIX that describes it has an associated
X Visual; for GLXPixmaps and GLXPbuffers there may or may not be an
X Visual associated with the GLXFBConfigSGIX.
Use glXChooseFBConfigSGIX to get GLXFBConfigSGIXs that match a
list of attributes or to get the list of GLXFBConfigSGIXs that are
available on the specified screen.
GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *dpy,
int screen,
const int *attrib_list,
int *nelements);
If < attrib_list > is NULL then glXChooseFBConfigSGIX returns an array of
GLXFBConfigSGIXs that are available on the specified screen; otherwise this
call returns an array of GLXFBConfigSGIXs that match the specified attributes.
(The attributes are described in Table 3.) The number of elements
in the array is returned in nelements. The attributes are matched in
an attribute-specific manner, as shown in Table 4. Some of the attributes,
such as GLX_LEVEL, must match the specified value exactly; others, such as,
GLX_RED_SIZE must meet or exceed the specified minimum values. To retrieve
the GLXFBConfigSGIX, given an i.d., use the GLX_FBCONFIG_ID_SGIX attribute.
When GLX_FBCONFIG_ID_SGIX is specified, all other attributes are ignored,
and only the GLXFBConfigSGIX with the given XID is returned (NULL is returned
if it does not exist).
If no conforming GLXFBConfigSGIX exists, or if an error occurs (i.e., an
undefined GLX attribute is encountered in < attrib_list >, < screen > is
invalid, or < dpy > does not support the GLX extension) then NULL is
returned. If < attrib_list > is not NULL and more than one GLXFBConfigSGIX is
found, then a list of GLXFBConfigSGIXs, sorted according to the "best"
match criteria, is returned. The exact sorting precedence order is
defined below. Use XFree to free the memory returned by
glXChooseFBConfigSGIX.
If GLX_RENDER_TYPE_SGIX is in < attrib_list > then the value that follows
is a mask indicating which type of GLXContexts drawables created with
the corresponding GLXFBConfigSGIXs be bound to. For example, if
GLX_RGBA_BIT_SGIX | GLX_COLOR_INDEX_BIT_SGIX
is specified as the mask then glXChooseFBConfigSGIX will search for
GLXFBConfigSGIXs that can be used to create drawables that can be bound to both
RGBA and color index rendering contexts. The default value for
GLX_RENDER_TYPE_SGIX is GLX_RGBA_BIT_SGIX.
The attribute GLX_DRAWABLE_TYPE_SGIX has as its value a mask indicating
the drawable types that can be created with the corresponding GLXFBConfigSGIX
(the config is said to ``support'' these drawable types).
For example, a GLXFBConfigSGIX for which the value of GLX_DRAWABLE_TYPE_SGIX
attribute is GLX_WINDOW_BIT_SGIX | GLX_PIXMAP_BIT_SGIX can be used to create
both Windows and GLX pixmaps, while a config for which this attribute value
is GLX_WINDOW_BIT_SGIX can not be used for creating GLX pixmaps. The default
value for GLX_DRAWABLE_TYPE_SGIX is GLX_WINDOW_BIT_SGIX.
If a GLXFBConfigSGIX supports Windows then it has an associated X Visual. The
value of the GLX_X_VISUAL_TYPE_EXT attribute specifies the type of X
Visual. The possible values are:
GLX token name X Visual Type
-------------- -------------
GLX_TRUE_COLOR_EXT TrueColor
GLX_DIRECT_COLOR_EXT DirectColor
GLX_PSEUDO_COLOR_EXT PseudoColor
GLX_STATIC_COLOR_EXT StaticColor
GLX_GRAY_SCALE_EXT GrayScale
GLX_STATIC_GRAY_EXT StaticGray
Note that RGBA rendering may be supported for any of the six Visual types
but color index rendering is only supported for PseudoColor, StaticColor,
GrayScale, and StaticGray visuals (i.e., single-channel visuals). The
GLX_X_VISUAL_TYPE_EXT attribute is ignored if GLX_DRAWABLE_TYPE_SGIX is
specified in < attrib_list > and the mask that follows does not have
GLX_WINDOW_BIT_SGIX set.
GLX_X_RENDERABLE_SGIX is a boolean indicating whether X can be used
to render into a drawable created with the GLXFBConfigSGIX. This attribute
is True if the GLXFBConfigSGIX supports Windows and/or GLX pixmaps.
All attributes in < attrib_list >, including boolean attributes, are
immediately followed by the corresponding desired value. The list is
terminated with None. If an attribute is not specified in < attrib_list >
then the default value (listed in Table 4) is used (it is said to be
specified implicitly). For example, if GLX_STEREO is not specified then it
is assumed to be False. For some attributes, the default is "don't care"
meaning that any value is OK for this attribute, so the attribute will not
be checked.
When more than one GLXFBConfigSGIX matches the specification, a list of matching
configurations is returned. The list is sorted according to the following
precedence rules that are applied in ascending order (i.e., configurations
that are considered equal by lower numbered rule are sorted by the higher
numbered rule):
1. by GLX_VISUAL_RATING_EXT where the precedence is GLX_NONE_EXT,
GLX_SLOW_VISUAL.
2. larger total number of RGBA color components (GLX_RED_BITS,
GLX_GREEN_BITS, GLX_BLUE_BITS, and GLX_ALPHA_BITS) that have higher
number of bits,
3. smaller GLX_INDEX_BITS,
4. single buffered configuration (GLX_DOUBLE_BUFFER being False)
precedes a double buffered one,
5. smaller GLX_AUX_BUFFERS,
6. smaller GLX_SAMPLE_BUFFERS_SGIS,
7. smaller GLX_SAMPLES_SGIS,
8. larger GLX_DEPTH_BITS,
9. smaller GLX_STENCIL_BITS,
10. larger total number of accumulation buffer color components
(GLX_ACCUM_RED_BITS, GLX_ACCUM_GREEN_BITS, GLX_ACCUM_BLUE_BITS, and
GLX_ACCUM_ALPHA_BITS) that have higher number of bits;
11. sort by GLX_VISUAL_TYPE_EXT where the precedence order is
GLX_TRUE_COLOR_EXT, GLX_DIRECT_COLOR_EXT, GLX_PSEUDO_COLOR_EXT,
GLX_STATIC_COLOR_EXT, GLX_GRAY_SCALE_EXT, GLX_STATIC_GRAY_EXT,
To get the value of a GLX attribute for a GLXFBConfigSGIX use
int glXGetFBConfigAttribSGIX(Display *dpy,
GLXFBConfigSGIX config,
int attribute,
int *value);
If glXGetFBConfigAttribSGIX succeeds then it returns Success and the
value for the specified attribute is returned in < value >; otherwise
it returns one of the following errors:
GLX_BAD_ATTRIB < attribute > is not a valid GLX attribute
Refer to Tables 3 and 4 for a list of valid GLX attributes.
Note that a GLXFBConfigSGIX has an associated X Visual iff the
GLX_DRAWABLE_TYPE_SGIX value has the GLX_WINDOW_BIT_SGIX bit set. To
retrieve the associated visual, call:
XVisualInfo *glXGetVisualFromFBConfigSGIX(Display *dpy,
GLXFBConfigSGIX config);
If < config > is a valid GLXFBConfigSGIX and it has an associated X Visual then
information describing that visual is returned; otherwise NULL is returned.
Use XFree to free the data returned.
It is also possible to get a GLXFBConfigSGIX, given visual information:
GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy,
XVisualInfo *vis);
If the visual is valid and supports OpenGL rendering (i.e., if the GLX
visual attribute GLX_USE_GL is True) then the associated GLXFBConfigSGIX is
returned; otherwise NULL is returned.
[Change Table 1 caption to read: "GLX Configuration attributes for Visuals"
and add the tables below]
Attribute Type Description
--------- ---- -----------
GLX_BUFFER_SIZE integer depth of the color buffer
GLX_LEVEL integer frame buffer level
GLX_DOUBLEBUFFER boolean True if color buffers have
front/back pairs
GLX_STEREO boolean True if color buffers have
left/right pairs
GLX_AUX_BUFFERS integer number of auxiliary color buffers
GLX_RED_SIZE integer number of bits of Red in the
framebuffer
GLX_GREEN_SIZE integer number of bits of Green in the
framebuffer
GLX_BLUE_SIZE integer number of bits of Blue in the
framebuffer
GLX_ALPHA_SIZE integer number of bits of Alpha in the
framebuffer
GLX_DEPTH_SIZE integer number of bits in the depth buffer
GLX_STENCIL_SIZE integer number of bits in the stencil buffer
GLX_ACCUM_RED_SIZE integer number of bits of Red in the
accumulation buffer
GLX_ACCUM_GREEN_SIZE integer number of bits of Green in the
accumulation buffer
GLX_ACCUM_BLUE_SIZE integer number of bits of Blue in the
accumulation buffer
GLX_ACCUM_ALPHA_SIZE integer number of bits of Alpha in the
accumulation buffer
GLX_SAMPLE_BUFFERS_SGIS integer number of multisample buffers
GLX_SAMPLES_SGIS integer number of samples stored in each
multisample buffer
GLX_X_VISUAL_TYPE_EXT integer X visual type of the associated visual
GLX_TRANSPARENT_TYPE_EXT enum GLX_NONE_EXT,
TRANSPARENT_RGB_EXT, or
TRANSPARENT_INDEX_EXT
GLX_TRANSPARENT_INDEX_VALUE_EXT integer transparent index value.
GLX_TRANSPARENT_RED_VALUE_EXT integer transparent red value.
GLX_TRANSPARENT_GREEN_VALUE_EXT integer transparent green value.
GLX_TRANSPARENT_BLUE_VALUE_EXT integer transparent blue value.
GLX_TRANSPARENT_ALPHA_VALUE_EXT integer transparent alpha value.
GLX_VISUAL_CAVEAT_EXT enum GLX_NONE_EXT or GLX_SLOW_VISUAL_EXT
GLX_DRAWABLE_TYPE_SGIX bitmask mask indicating which GLX drawables
are supported. Valid bits are
GLX_WINDOW_BIT_SGIX and
GLX_PIXMAP_BIT_SGIX
GLX_RENDER_TYPE_SGIX bitmask mask indicating which OpenGL
rendering modes are
supported. Valid bits are
GLX_RGBA_BIT_SGIX and
GLX_COLOR_INDEX_SGIX.
GLX_X_RENDERABLE_SGIX boolean True if X can render to drawable
GLX_FBCONFIG_ID_SGIX XID i.d. of GLXFBConfigSGIX
Table 3: GLXFBConfigSGIX attributes (Note that GLX_RGBA and GLX_USE_GL
are not supported for GLXFBConfigSGIXs)
Attribute Default Sorting Criterion
--------- ------- -----------------
GLX_BUFFER_SIZE 0 smaller
GLX_LEVEL 0 exact
GLX_DOUBLEBUFFER don't care smaller
GLX_STEREO False exact
GLX_AUX_BUFFERS 0 smaller
GLX_RED_SIZE 0 larger
GLX_GREEN_SIZE 0 larger
GLX_BLUE_SIZE 0 larger
GLX_ALPHA_SIZE 0 larger
GLX_DEPTH_SIZE 0 larger
GLX_STENCIL_SIZE 0 larger
GLX_ACCUM_RED_SIZE 0 larger
GLX_ACCUM_GREEN_SIZE 0 larger
GLX_ACCUM_BLUE_SIZE 0 larger
GLX_ACCUM_ALPHA_SIZE 0 larger
GLX_SAMPLE_BUFFERS_SGIS 0 smaller
GLX_SAMPLES_SGIS 0 smaller
GLX_X_VISUAL_TYPE_EXT don't care exact
GLX_TRANSPARENT_TYPE_EXT GLX_NONE_EXT exact
GLX_TRANSPARENT_INDEX_VALUE_EXT don't care exact
GLX_TRANSPARENT_RED_VALUE_EXT don't care exact
GLX_TRANSPARENT_GREEN_VALUE_EXT don't care exact
GLX_TRANSPARENT_BLUE_VALUE_EXT don't care exact
GLX_TRANSPARENT_ALPHA_VALUE_EXT don't care exact
GLX_VISUAL_CAVEAT_EXT don't care exact
GLX_DRAWABLE_TYPE_SGIX GLX_WINDOW_BIT_SGIX mask
GLX_RENDER_TYPE_SGIX GLX_RGBA_BIT_SGIX mask
GLX_X_RENDERABLE_SGIX don't care exact
GLX_FBCONFIG_ID_SGIX don't care exact
Table 4: Default values and match criteria for GLXFBConfigSGIX attributes. The
definition of the sorting criteria is as follow:
smaller - configs with attribute value that meets or exceeds the
specified value are returned, with precedence given to smaller
values (when a value is not explicitly requested, the default is
implied);
larger - when the value is requested explicitly, only configs
with a corresponding attribute value that meet or exceed the
specified value are returned, with precedence given to larger
values. When the value is not requested explicitly behaves exactly
like the ``smaller'' criterion.
exact - only configs whose corresponding attribute value exactly
matches the requested value are considered.
mask - only configs for which the set bits of corresponding
attribute include all the bits that are set in the requested
value are considered (Additional bits might be set in the
attribute).
[Add the following to section 3.2.3 on Offscreen Rendering]
To create a GLX pixmap using a GLXFBConfigSGIX use
GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy,
GLXFBConfigSGIX config,
Pixmap pixmap);
This call is identical to glXCreateGLXPixmap except that the GLXPixmap
is created with color buffers and ancillary buffers as specified by
< config >. If < config > is not a valid GLXFBConfigSGIX, or if it does not
support pixmap rendering then a GLXBadFBConfigSGIX error is generated.
[Add the following to section 3.2.4 on Rendering Contexts]
To create a GLX context using a GLXFBConfigSGIX call
GLXContext glXCreateContextWithConfigSGIX(Display *dpy,
GLXFBConfigSGIX config,
int render_type,
GLXContext share_list,
Bool direct);
This call is identical to glXCreateContext except that the resulting
GLXContext can be used to render to any "compatible" GLXDrawable. A
GLXContext and a GLXDrawable are compatible if
- the render_type attribute for the context is supported by the
GLXFBConfigSGIX that the drawable was created with. (e.g., if the
context was created with render_type GLX_RGBA_TYPE_SGIX, then
the GLXFBConfigSGIX's GLX_RENDER_TYPE_SGIX attribute must have
the GLX_RGBA_BIT_SGIX bit set.)
- all color buffers and ancillary buffers that exist in both
GLXFBConfigSGIXs have the same depth. For example, a GLXDrawable that
had a front left buffer and a back left buffer with red, green and
blue sizes of 4 would not be compatible with a GLXFBConfigSGIX that had
only a front left buffer with red, green and blue sizes of 8. However,
it would be compatible with a GLXFBConfigSGIX that had only a front left
buffer if the red, green and blue sizes were 4.
glXCreateContextWithConfigSGIX can generate the following errors:
GLXBadContext if < share_list > is neither zero nor a valid GLX
rendering context; GLXBadFBConfigSGIX if < config > is not a valid
GLXFBConfigSGIX; BadMatch if < share_list > defines an address space that
cannot be shared with the newly created context or if < share_list >
was created on a different screen than the one referenced by < config >;
BadAlloc if the server does not have enough resources to allocate the
new context; BadValue if < render_type > does not refer to a valid
rendering type.
[Add to description of glXMakeCurrent]
No error will be generated if the value of DRAW_BUFFER in < ctx >
indicates a color buffer that is not supported by < drawable >.
In this case, all rendering will behave as if DRAW_BUFFER was
set to NONE. The same goes for READ_BUFFER: no error will be
generated if it does not correspond to a valid color buffer;
subsequent glReadPixel and glCopyPixel operations will simply
return invalid data.
Note that it is an error to later call glDrawBuffer and/or glReadBuffer
(even if they are implicitly called via glPopAttrib) and specify
a color buffer that is not supported by < drawable >. Also
subsequent calls to glCopyPixels, that specify an unsupported
ancillary buffer, will result in an error.
[Add to table listing GLX context attributes for glXQueryContextInfoEXT]
GLX context attribute type context information
--------------------- ---- -------------------
GLX_FBCONFIG_ID_SGIX XID FBConfig id
GLX Protocol
>>> to be filled in
Dependencies on SGIS_multisample
If SGIS_multisample is not supported, references to
GLX_SAMPLE_BUFFERS_SGIS and GLX_SAMPLES_SGIS in this document are
invalid and should be ignored.
Dependencies on EXT_visual_info
If EXT_visual_info is not supported, references to
GLX_X_VISUAL_TYPE_EXT, GLX_TRANSPARENT_TYPE_EXT,
GLX_TRANSPARENT_INDEX_VALUE_EXT, GLX_TRANSPARENT_RED_VALUE_EXT,
GLX_TRANSPARENT_GREEN_VALUE_EXT, GLX_TRANSPARENT_BLUE_VALUE_EXT,
GLX_TRANSPARENT_ALPHA_VALUE_EXT, GLX_TRUE_COLOR_EXT,
GLX_DIRECT_COLOR_EXT, GLX_PSEUDO_COLOR_EXT, GLX_STATIC_COLOR_EXT,
GLX_GRAY_SCALE_EXT, and GLX_STATIC_GRAY_EXT, in this document
are invalid and should be ignored.
Dependencies on EXT_visual_rating
If EXT_visual_rating is not supported, references to GLX_VISUAL_CAVEAT_EXT
and GLX_SLOW_VISUAL_EXT, in this document are invalid and should be ignored.
Dependencies on EXT_import_context
If EXT_import_context is not supported, references to glXQueryContextInfoEXT
in this document should be ignored.
Dependencies on SGIX_pbuffer
If SGIX_pbuffer is not supported, references to glXQueryGLXPbufferSGIX
and GLXPbuffer in this document should be ignored.
Errors
One new GLX error is introduced:
GLXBadFBConfigSGIX
New State
None
New Implementation Dependent State
None