xref: /third_party/openGLES/extensions/SGIX/GLX_SGIX_fbconfig.txt (revision 5bd8dead)

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 <attribute> parameter of glXGetFBConfigAttribSGIX, and 
    by the <attrib_list> parameter of glXChooseFBConfigSGIX:

        GLX_DRAWABLE_TYPE_SGIX		0x8010
        GLX_RENDER_TYPE_SGIX		0x8011
        GLX_X_RENDERABLE_SGIX		0x8012

    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		0x8013

    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		0x00000001
	GLX_PIXMAP_BIT_SGIX		0x00000002

    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		0x00000001
	GLX_COLOR_INDEX_BIT_SGIX	0x00000002

    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

	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