Name SGIX_fbconfig Name Strings GLX_SGIX_fbconfig Version $Date: 1997/03/24 18:56:20 $ $Revision: 1.16 $ 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 parameter of glXGetFBConfigAttribSGIX, and by the parameter of glXChooseFBConfigSGIX: GLX_DRAWABLE_TYPE_SGIX 0x8010 GLX_RENDER_TYPE_SGIX 0x8011 GLX_X_RENDERABLE_SGIX 0x8012 Accepted by the parameter of glXGetFBConfigAttribSGIX, the parameter of glXChooseFBConfigSGIX, by the parameter of glXQueryGLXPbufferSGIX and by the parameter of glXQueryContextInfoEXT: GLX_FBCONFIG_ID_SGIX 0x8013 Accepted by the parameter of glXGetFBConfigAttribSGIX: GLX_SCREEN_EXT 0x800C Returned by glXGetFBConfigAttribSGIX (when is set to GLX_DRAWABLE_TYPE_SGIX) and accepted by the parameter of glXChooseFBConfigSGIX (following the GLX_DRAWABLE_TYPE_SGIX token): GLX_WINDOW_BIT_SGIX 0x00000001 GLX_PIXMAP_BIT_SGIX 0x00000002 Returned by glXGetFBConfigAttribSGIX (when is set to GLX_RENDER_TYPE_SGIX) and accepted by the parameter of glXChooseFBConfigSGIX (following the GLX_RENDER_TYPE_SGIX token): GLX_RGBA_BIT_SGIX 0x00000001 GLX_COLOR_INDEX_BIT_SGIX 0x00000002 Accepted by the 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 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 , is invalid, or does not support the GLX extension) then NULL is returned. If 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 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 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 , including boolean attributes, are immediately followed by the corresponding desired value. The list is terminated with None. If an attribute is not specified in 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 ; otherwise it returns one of the following errors: GLX_BAD_ATTRIB 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 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 . If 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 is neither zero nor a valid GLX rendering context; GLXBadFBConfigSGIX if is not a valid GLXFBConfigSGIX; BadMatch if defines an address space that cannot be shared with the newly created context or if was created on a different screen than the one referenced by ; BadAlloc if the server does not have enough resources to allocate the new context; BadValue if 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 indicates a color buffer that is not supported by . 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 . 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 Three newGLX protocol commands are added. GetFBConfigsSGIX 1 CARD8 opcode (X assigned) 1 17 GLX opcode (glXVendorPrivateWithReply) 2 4 request length 4 65540 vendor specific opcode 4 unused 4 CARD32 screen => 1 1 reply 1 unused 2 CARD16 sequence number 4 n*m length 4 n numFBConfigs 4 m numAttribs 20 unused 8 * n LISTofATTRIB properties Where n is the number of FBConfigs returned and m is the number of attributes returned for each FBConfig. Both m and n are of type CARD32. CreateContextWithConfigSGIX 1 CARD8 opcode (X assigned) 1 17 GLX opcode (glXVendorPrivateWithReply) 2 9 request length 4 65541 vendor specific opcode 4 unused 4 GLX_CONTEXT context 4 GLX_FBCONFIG fbconfig 4 CARD32 screen 4 CARD32 renderType 4 GLX_CONTEXT shareList 1 BOOL isDirect 1 CARD8 reserved1 1 CARD16 reserved2 CreateGLXPixmapWithConfigSGIX 1 CARD8 opcode (X assigned) 1 17 GLX opcode (glXVendorPrivateWithReply) 2 7 request length 4 65542 vendor specific opcode 4 unused 4 CARD32 screen 4 GLX_FBCONFIG fbconfig 4 CARD32 pixmap 4 GLX_PIXMAP glxpixmap 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