home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / documents / OpenGL / opengldoc / glspec / fbconfig.spec < prev    next >
Encoding:
Text File  |  1996-11-11  |  25.9 KB  |  588 lines
  1. Name
  2.  
  3.     SGIX_fbconfig
  4.  
  5. Name Strings
  6.  
  7.     GLX_SGIX_fbconfig
  8.  
  9. Version
  10.     
  11.     $Date: 1996/04/01 23:22:43 $ $Revision: 1.1 $
  12.  
  13. Number
  14.  
  15.     49
  16.  
  17. Dependencies
  18.  
  19.     SGIS_multisample affects the definition of this extension
  20.     EXT_visual_info affects the definition of this extension
  21.     EXT_visual_rating affects the definition of this extension
  22.     EXT_import_context affects the definition of this extension
  23.     SGIX_pbuffer affects the definition of this extension
  24.  
  25. Overview
  26.  
  27.     This extension introduces a new way to describe the capabilities of a 
  28.     GLX drawable (i.e., to describe the depth of color buffer components 
  29.     and the type and size of ancillary buffers), removes the "similarity"
  30.     requirement when making a context current to a drawable, and supports 
  31.     RGBA rendering to one- and two-component Windows and GLX Pixmaps.
  32.  
  33.     Currently GLX overloads X Visuals with information on GLX drawable
  34.     capabilities. This extension defines a new construct, a GLXFBConfigSGIX,
  35.     that encapsulates GLX drawable capabilities and has the following 
  36.     properties:
  37.     
  38.        - It may or may not have an associated X visual. If it does have 
  39.        an associated X visual then it is possible to create Windows that  
  40.        have the capabilities described by the GLXFBConfig.
  41.  
  42.        - A particular GLXFBConfig does not need to work with all GLX 
  43.        drawables. For example, it is possible for implementations to export 
  44.        GLXFBConfigs that only work with GLX pixmaps.
  45.  
  46.     This extension also removes the "similarity" restriction when making
  47.     a context and drawable current. Instead a less restrictive requirement 
  48.     of "compatibility" (see definition below) is imposed. Note that when 
  49.     a context is created it has an associated rendering type which
  50.     is either RGBA or color index. In the future we may want to remove all
  51.     "similarity" and "compatibility" restrictions and allow a context to be
  52.     bound to any drawable that supports its rendering type.
  53.  
  54.     Finally the current GLX specification requires that the GLX_RGBA visual
  55.     attribute be associated only with X visual types TrueColor and DirectColor. 
  56.     This extension defines the semantics for doing RGBA rendering to Windows
  57.     created with visuals of type PseudoColor, StaticColor, GrayScale, and 
  58.     StaticGray.  In each of these cases, the red component is used to
  59.     generate the display, and the green and blue components, if present,
  60.     are ignored for display purposes.  
  61.  
  62.     The OpenGL RGBA rendering semantics are more powerful than the OpenGL
  63.     index rendering semantics.  By extending the number of X visual types
  64.     that can be associated with an RGBA color buffer, this extension allows
  65.     RGBA rendering semantics to be used with pseudo color and gray scale
  66.     displays.  An especially useful application of this extension is
  67.     support of one- and two-component RGBA drawables; drawables whose green,
  68.     blue, and sometimes alpha components have no bitplanes.
  69.  
  70.  
  71. Issues
  72.  
  73.     *    Should GLXFBConfigs apply to all GLX drawables or just GLXPbuffers?
  74.  
  75.         A: For consistency, all GLX drawables should be supported. (And if this 
  76.         extension is incorporated in a future release of GLX then the existing 
  77.         calls that rely on XVisualInfo structures should be deprecated.) The 
  78.         current mechanism which ties the description of GLX drawables to
  79.         X visuals is inadequate since it restricts all drawable configurations
  80.         to those which can be supported by on-screen windows.
  81.  
  82.     *   Should the selection of an FBConfig differ from glXChooseVisual? If 
  83.     so, how? 
  84.  
  85.         Yes. For some attributes, the default value (that is, the value that is
  86.         used if the attribute is not specified in the list) should be "don't 
  87.         care". Also, an ordered list of GLXFBConfigs should be returned so 
  88.         applications can go through the list and apply their own policies to 
  89.         determine the best GLXFBConfig.
  90.  
  91.     *   Do we want to introduce the notion of "compatible" GLXFBConfigs and 
  92.     visuals? (GLX currently uses the term "similar". GLXContexts and 
  93.     GLXDrawables are similar iff they have been created with respect 
  94.     to the same VisualID and root window.)
  95.    
  96.         A: Yes. The GLX definition of similar visuals is too restrictive 
  97.     (and the glXMakeCurrentRead extension already relaxes it.) This 
  98.     is the right time to agree on a definition since we need to define 
  99.     how GLXFBConfigs match up to X Visuals. Note, that we do not 
  100.     redefine similar; instead a new term, compatible, is introduced.
  101.         In the future, we may want to remove this restriction and allow
  102.         a context to be bound to any drawable. (But a context would still
  103.         be created to do either RGBA or color index rendering.)
  104.  
  105.  
  106. New Procedures and Functions
  107.  
  108.     int glXGetFBConfigAttribSGIX(Display *dpy, 
  109.                      GLXFBConfigSGIX config,
  110.                      int attribute,
  111.                      int *value);
  112.                        
  113.     GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *dpy, 
  114.                            int screen,
  115.                            const int *attrib_list,
  116.                            int *nelements);
  117.                        
  118.     GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy, 
  119.                                       GLXFBConfig config,
  120.                               Pixmap pixmap);
  121.  
  122.     GLXContext glXCreateContextWithConfigSGIX(Display *dpy,  
  123.                                               GLXFBConfig config,
  124.                           int render_type,
  125.                                               GLXContext share_list,
  126.                            Bool direct);
  127.  
  128.     XVisualInfo *glXGetVisualFromFBConfigSGIX(Display *dpy,
  129.                                               GLXFBConfig config);
  130.  
  131.     GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy,
  132.                                                  XVisualInfo *vis);
  133.  
  134. New Tokens
  135.  
  136.     Accepted by the <attribute> parameter of glXGetFBConfigAttribSGIX, and 
  137.     by the <attrib_list> parameter of glXChooseFBConfigSGIX:
  138.  
  139.         GLX_DRAWABLE_TYPE_SGIX        0x8010
  140.         GLX_RENDER_TYPE_SGIX        0x8011
  141.         GLX_X_RENDERABLE_SGIX        0x8012
  142.  
  143.     Accepted by the <attribute> parameter of glXGetFBConfigAttribSGIX, the
  144.     <attrib_list> parameter of glXChooseFBConfigSGIX, by the <attribute> 
  145.     parameter of glXQueryGLXPbufferSGIX and by the <attribute> parameter
  146.     of glXQueryContextInfoEXT:
  147.  
  148.     GLX_FBCONFIG_ID_SGIX        0x8013
  149.  
  150.     Accepted by the <attribute> parameter of glXGetFBConfigAttribSGIX:
  151.  
  152.         GLX_SCREEN_EXT            0x800C
  153.     
  154.     Returned by glXGetFBConfigAttribSGIX (when <attribute> is set to 
  155.     GLX_DRAWABLE_TYPE_SGIX) and accepted by the <attrib_list> parameter of 
  156.     glXChooseFBConfigSGIX (following the GLX_DRAWABLE_TYPE_SGIX token):
  157.  
  158.         GLX_WINDOW_BIT_SGIX        0x00000001
  159.     GLX_PIXMAP_BIT_SGIX        0x00000002
  160.  
  161.     Returned by glXGetFBConfigAttribSGIX (when <attribute> is set to 
  162.     GLX_RENDER_TYPE_SGIX) and accepted by the <attrib_list> parameter of 
  163.     glXChooseFBConfigSGIX (following the GLX_RENDER_TYPE_SGIX token):
  164.  
  165.         GLX_RGBA_BIT_SGIX        0x00000001
  166.     GLX_COLOR_INDEX_BIT_SGIX    0x00000002
  167.  
  168.     Accepted by the <render_type> parameter of glXCreateContextWithConfigSGIX:
  169.  
  170.         GLX_RGBA_TYPE_SGIX        0x8014
  171.     GLX_COLOR_INDEX_TYPE_SGIX    0x8015
  172.  
  173. Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation)
  174.  
  175.     None
  176.  
  177. Additions to Chapter 3 of the 1.0 Specification (Rasterization)
  178.  
  179.     None
  180.  
  181. Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations
  182. and the Frame buffer)
  183.  
  184.     In section 4.1.6 (Blending) follow the sentence "If a color buffer has
  185.     no A value, then it is as if the destination A value is 1." with the
  186.     sentence "If the color buffer has no R, G, or B value, then it is as
  187.     if the destination R, G, or B value is 0."
  188.  
  189.     In section 4.3.2 (Reading Pixels) follow the sentence "If the framebuffer
  190.     does not support alpha values then the A that is obtained is 1.0." with
  191.     the sentence "If the framebuffer does not support red, green, or blue
  192.     values, then the R, G or B that is obtained is 0.0."
  193.  
  194. Additions to Chapter 5 of the 1.0 Specification (Special Functions)
  195.  
  196.     None
  197.  
  198. Additions to Chapter 6 of the 1.0 Specification (State and State Requests)
  199.  
  200.     None
  201.  
  202. Additions to the GLX Specification
  203.  
  204.     [Add the following to section 3.2.2 on Configuration Management]
  205.  
  206.     A GLXFBConfigSGIX describes the format, type and size of the color 
  207.     buffers and ancillary buffers for a GLXDrawable. When the GLXDrawable
  208.     is a window then the GLXFBConfigSGIX that describes it has an associated
  209.     X Visual; for GLXPixmaps and GLXPbuffers there may or may not be an
  210.     X Visual associated with the GLXFBConfigSGIX.
  211.  
  212.     Use glXChooseFBConfigSGIX to get GLXFBConfigSGIXs that match a
  213.     list of attributes or to get the list of GLXFBConfigSGIXs that are
  214.     available on the specified screen.
  215.  
  216.         GLXFBConfigSGIX *glXChooseFBConfigSGIX(Display *dpy, 
  217.                       int screen,
  218.                       const int *attrib_list,
  219.                           int *nelements);
  220.  
  221.     If <attrib_list> is NULL then glXChooseFBConfigSGIX returns an array of 
  222.     GLXFBConfigSGIXs that are available on the specified screen; otherwise this
  223.     call returns an array of GLXFBConfigSGIXs that match the specified attributes. 
  224.     (The attributes are described in Table 3.) The number of elements
  225.     in the array is returned in nelements.   The attributes are matched in 
  226.     an attribute-specific manner, as shown in Table 4. Some of the attributes, 
  227.     such as GLX_LEVEL, must match the specified value exactly; others, such as, 
  228.     GLX_RED_SIZE must meet or exceed the specified minimum values. To retrieve
  229.     the GLXFBConfigSGIX, given an i.d., use the GLX_FBCONFIG_ID_SGIX attribute.
  230.     When GLX_FBCONFIG_ID_SGIX is specified, all other attributes are ignored,
  231.     and only the GLXFBConfigSGIX with the given XID is returned (NULL is returned
  232.     if it does not exist).
  233.  
  234.     If no conforming GLXFBConfigSGIX exists, or if an error occurs (i.e., an 
  235.     undefined GLX attribute is encountered in <attrib_list>, <screen> is 
  236.     invalid, or <dpy> does not support the GLX extension) then NULL is 
  237.     returned. If <attrib_list> is not NULL and more than one GLXFBConfigSGIX is 
  238.     found, then a list of GLXFBConfigSGIXs, sorted according to the "best"
  239.     match criteria, is returned.  The exact sorting precedence order is 
  240.     defined below.  Use XFree to free the memory returned by
  241.     glXChooseFBConfigSGIX.
  242.  
  243.     If GLX_RENDER_TYPE_SGIX is in <attrib_list> then the value that follows
  244.     is a mask indicating which type of GLXContexts drawables created with
  245.     the corresponding GLXFBConfigSGIXs be bound to. For example, if 
  246.         GLX_RGBA_BIT_SGIX | GLX_COLOR_INDEX_BIT_SGIX 
  247.     is specified as the mask then glXChooseFBConfigSGIX will search for 
  248.     GLXFBConfigSGIXs that can be used to create drawables that can be bound to both 
  249.     RGBA and color index rendering contexts. The default value for
  250.     GLX_RENDER_TYPE_SGIX is GLX_RGBA_BIT_SGIX. 
  251.  
  252.     The attribute GLX_DRAWABLE_TYPE_SGIX has as its value a mask indicating
  253.     the drawable types that can be created with the corresponding GLXFBConfigSGIX
  254.     (the config is said to ``support'' these drawable types).
  255.     For example, a GLXFBConfigSGIX for which the value of GLX_DRAWABLE_TYPE_SGIX
  256.     attribute is GLX_WINDOW_BIT_SGIX | GLX_PIXMAP_BIT_SGIX can be used to create
  257.     both Windows and GLX pixmaps, while a config for which this attribute value
  258.     is GLX_WINDOW_BIT_SGIX can not be used for creating GLX pixmaps. The default
  259.     value for GLX_DRAWABLE_TYPE_SGIX is GLX_WINDOW_BIT_SGIX.
  260.  
  261.     If a GLXFBConfigSGIX supports Windows then it has an associated X Visual. The
  262.     value of the GLX_X_VISUAL_TYPE_EXT attribute specifies the type of X
  263.     Visual. The possible values are:
  264.  
  265.         GLX token name                  X Visual Type
  266.         --------------                  -------------
  267.         GLX_TRUE_COLOR_EXT              TrueColor
  268.         GLX_DIRECT_COLOR_EXT            DirectColor
  269.         GLX_PSEUDO_COLOR_EXT            PseudoColor
  270.         GLX_STATIC_COLOR_EXT            StaticColor
  271.         GLX_GRAY_SCALE_EXT              GrayScale
  272.         GLX_STATIC_GRAY_EXT             StaticGray
  273.  
  274.     Note that RGBA rendering may be supported for any of the six Visual types
  275.     but color index rendering is only supported for PseudoColor, StaticColor,
  276.     GrayScale, and StaticGray visuals (i.e., single-channel visuals). The
  277.     GLX_X_VISUAL_TYPE_EXT attribute is ignored if GLX_DRAWABLE_TYPE_SGIX is
  278.     specified in <attrib_list> and the mask that follows does not have
  279.     GLX_WINDOW_BIT_SGIX set.
  280.  
  281.     GLX_X_RENDERABLE_SGIX is a boolean indicating whether X can be used
  282.     to render into a drawable created with the GLXFBConfigSGIX. This attribute
  283.     is True if the GLXFBConfigSGIX supports Windows and/or GLX pixmaps.
  284.  
  285.     All attributes in <attrib_list>, including boolean attributes, are 
  286.     immediately followed by the corresponding desired value. The list is 
  287.     terminated with None. If an attribute is not specified in <attrib_list> 
  288.     then the default value (listed in Table 4) is used (it is said to be
  289.     specified implicitly).  For example, if GLX_STEREO is not specified then it
  290.     is assumed to be False.  For some attributes, the default is "don't care"
  291.     meaning that any value is OK for this attribute, so the attribute will not
  292.     be checked.
  293.  
  294.     When more than one GLXFBConfigSGIX matches the specification, a list of matching
  295.     configurations is returned. The list is sorted according to the following
  296.     precedence rules that are applied in ascending order (i.e., configurations
  297.     that are considered equal by lower numbered rule are sorted by the higher
  298.     numbered rule):
  299.  
  300.      1. by GLX_VISUAL_RATING_EXT where the precedence is GLX_NONE_EXT,
  301.         GLX_SLOW_VISUAL.
  302.      2. larger total number of RGBA color components (GLX_RED_BITS,
  303.         GLX_GREEN_BITS, GLX_BLUE_BITS, and GLX_ALPHA_BITS) that have higher
  304.         number of bits,
  305.      3. smaller GLX_INDEX_BITS,
  306.      4. single buffered configuration (GLX_DOUBLE_BUFFER being False)
  307.         precedes a double buffered one,
  308.      5. smaller GLX_AUX_BUFFERS,
  309.      6. smaller GLX_SAMPLE_BUFFERS_SGIS,
  310.      7. smaller GLX_SAMPLES_SGIS,
  311.      8. larger GLX_DEPTH_BITS,
  312.      9. smaller GLX_STENCIL_BITS,
  313.     10. larger total number of accumulation buffer color components
  314.         (GLX_ACCUM_RED_BITS, GLX_ACCUM_GREEN_BITS, GLX_ACCUM_BLUE_BITS, and
  315.         GLX_ACCUM_ALPHA_BITS) that have higher number of bits;
  316.     11. sort by GLX_VISUAL_TYPE_EXT where the precedence order is
  317.         GLX_TRUE_COLOR_EXT, GLX_DIRECT_COLOR_EXT, GLX_PSEUDO_COLOR_EXT,
  318.         GLX_STATIC_COLOR_EXT, GLX_GRAY_SCALE_EXT, GLX_STATIC_GRAY_EXT,
  319.  
  320.     To get the value of a GLX attribute for a GLXFBConfigSGIX use
  321.  
  322.         int glXGetFBConfigAttribSGIX(Display *dpy, 
  323.                          GLXFBConfigSGIX config,
  324.                          int attribute,
  325.                          int *value);
  326.  
  327.     If glXGetFBConfigAttribSGIX succeeds then it returns Success and the 
  328.     value for the specified attribute is returned in <value>; otherwise 
  329.     it returns one of the following errors:
  330.  
  331.         GLX_BAD_ATTRIB <attribute> is not a valid GLX attribute 
  332.  
  333.     Refer to Tables 3 and 4 for a list of valid GLX attributes. 
  334.  
  335.     Note that a GLXFBConfigSGIX has an associated X Visual iff the 
  336.     GLX_DRAWABLE_TYPE_SGIX value has the GLX_WINDOW_BIT_SGIX bit set. To 
  337.     retrieve the associated visual, call:
  338.  
  339.       XVisualInfo *glXGetVisualFromFBConfigSGIX(Display *dpy,
  340.                                                 GLXFBConfigSGIX config);
  341.   
  342.     If <config> is a valid GLXFBConfigSGIX and it has an associated X Visual then 
  343.     information describing that visual is returned; otherwise NULL is returned.
  344.     Use XFree to free the data returned.
  345.  
  346.     It is also possible to get a GLXFBConfigSGIX, given visual information:
  347.  
  348.       GLXFBConfigSGIX glXGetFBConfigFromVisualSGIX(Display *dpy,
  349.                                                XVisualInfo *vis);
  350.  
  351.     If the visual is valid and supports OpenGL rendering (i.e., if the GLX 
  352.     visual attribute GLX_USE_GL is True) then the associated GLXFBConfigSGIX is 
  353.     returned; otherwise NULL is returned.
  354.  
  355.  
  356.     [Change Table 1 caption to read: "GLX Configuration attributes for Visuals" 
  357.      and add the tables below]
  358.  
  359.     Attribute                    Type     Description
  360.     ---------                         ----     -----------
  361.     GLX_BUFFER_SIZE                   integer  depth of the color buffer
  362.     GLX_LEVEL                         integer  frame buffer level
  363.     GLX_DOUBLEBUFFER            boolean  True if color buffers have
  364.                              front/back pairs
  365.     GLX_STEREO                boolean  True if color buffers have
  366.                              left/right pairs
  367.     GLX_AUX_BUFFERS                   integer  number of auxiliary color buffers
  368.     GLX_RED_SIZE                      integer  number of bits of Red in the
  369.                              framebuffer
  370.     GLX_GREEN_SIZE                    integer  number of bits of Green in the
  371.                              framebuffer
  372.     GLX_BLUE_SIZE                     integer  number of bits of Blue in the
  373.                              framebuffer
  374.     GLX_ALPHA_SIZE                    integer  number of bits of Alpha in the
  375.                              framebuffer
  376.     GLX_DEPTH_SIZE                    integer  number of bits in the depth buffer
  377.     GLX_STENCIL_SIZE                  integer  number of bits in the stencil buffer
  378.     GLX_ACCUM_RED_SIZE                integer  number of bits of Red in the 
  379.                          accumulation buffer
  380.     GLX_ACCUM_GREEN_SIZE              integer  number of bits of Green in the
  381.                          accumulation buffer
  382.     GLX_ACCUM_BLUE_SIZE               integer  number of bits of Blue in the 
  383.                          accumulation buffer
  384.     GLX_ACCUM_ALPHA_SIZE              integer  number of bits of Alpha in the
  385.                          accumulation buffer
  386.     GLX_SAMPLE_BUFFERS_SGIS           integer  number of multisample buffers
  387.     GLX_SAMPLES_SGIS                  integer  number of samples stored in each
  388.                          multisample buffer
  389.     GLX_X_VISUAL_TYPE_EXT        integer  X visual type of the associated visual
  390.     GLX_TRANSPARENT_TYPE_EXT         enum     GLX_NONE_EXT,
  391.                                  TRANSPARENT_RGB_EXT, or 
  392.                                  TRANSPARENT_INDEX_EXT
  393.     GLX_TRANSPARENT_INDEX_VALUE_EXT integer  transparent index value.
  394.     GLX_TRANSPARENT_RED_VALUE_EXT   integer  transparent red value.
  395.     GLX_TRANSPARENT_GREEN_VALUE_EXT integer  transparent green value.
  396.     GLX_TRANSPARENT_BLUE_VALUE_EXT  integer  transparent blue value.
  397.     GLX_TRANSPARENT_ALPHA_VALUE_EXT integer  transparent alpha value.
  398.     GLX_VISUAL_CAVEAT_EXT        enum     GLX_NONE_EXT or GLX_SLOW_VISUAL_EXT
  399.     GLX_DRAWABLE_TYPE_SGIX        bitmask  mask indicating which GLX drawables
  400.                          are supported.  Valid bits are
  401.                          GLX_WINDOW_BIT_SGIX and
  402.                          GLX_PIXMAP_BIT_SGIX
  403.     GLX_RENDER_TYPE_SGIX        bitmask  mask indicating which OpenGL
  404.                          rendering modes are
  405.                          supported. Valid bits are
  406.                          GLX_RGBA_BIT_SGIX and
  407.                          GLX_COLOR_INDEX_SGIX.
  408.     GLX_X_RENDERABLE_SGIX             boolean  True if X can render to drawable
  409.     GLX_FBCONFIG_ID_SGIX        XID      i.d. of GLXFBConfigSGIX
  410.  
  411.     Table 3: GLXFBConfigSGIX attributes (Note that GLX_RGBA and GLX_USE_GL
  412.              are not supported for GLXFBConfigSGIXs)
  413.  
  414.     Attribute                     Default                Sorting Criterion
  415.     ---------                          -------            -----------------
  416.     GLX_BUFFER_SIZE             0                smaller
  417.     GLX_LEVEL                 0                exact
  418.     GLX_DOUBLEBUFFER             don't care            smaller
  419.     GLX_STEREO                 False            exact
  420.     GLX_AUX_BUFFERS             0                smaller
  421.     GLX_RED_SIZE             0                larger
  422.     GLX_GREEN_SIZE             0                larger
  423.     GLX_BLUE_SIZE             0                larger
  424.     GLX_ALPHA_SIZE             0                larger
  425.     GLX_DEPTH_SIZE             0                larger
  426.     GLX_STENCIL_SIZE             0                larger
  427.     GLX_ACCUM_RED_SIZE             0                larger
  428.     GLX_ACCUM_GREEN_SIZE         0                larger
  429.     GLX_ACCUM_BLUE_SIZE             0                larger
  430.     GLX_ACCUM_ALPHA_SIZE         0                larger
  431.     GLX_SAMPLE_BUFFERS_SGIS         0                smaller
  432.     GLX_SAMPLES_SGIS             0                smaller
  433.     GLX_X_VISUAL_TYPE_EXT         don't care            exact
  434.     GLX_TRANSPARENT_TYPE_EXT         GLX_NONE_EXT        exact
  435.     GLX_TRANSPARENT_INDEX_VALUE_EXT  don't care            exact
  436.     GLX_TRANSPARENT_RED_VALUE_EXT    don't care            exact
  437.     GLX_TRANSPARENT_GREEN_VALUE_EXT  don't care            exact
  438.     GLX_TRANSPARENT_BLUE_VALUE_EXT   don't care            exact
  439.     GLX_TRANSPARENT_ALPHA_VALUE_EXT  don't care            exact
  440.     GLX_VISUAL_CAVEAT_EXT         don't care            exact
  441.     GLX_DRAWABLE_TYPE_SGIX         GLX_WINDOW_BIT_SGIX    mask
  442.     GLX_RENDER_TYPE_SGIX         GLX_RGBA_BIT_SGIX          mask
  443.     GLX_X_RENDERABLE_SGIX         don't care            exact
  444.     GLX_FBCONFIG_ID_SGIX         don't care            exact
  445.  
  446.     Table 4: Default values and match criteria for GLXFBConfigSGIX attributes.  The
  447.              definition of the sorting criteria is as follow:
  448.          smaller - configs with attribute value that meets or exceeds the
  449.            specified value are returned, with precedence given to smaller
  450.            values (when a value is not explicitly requested, the default is
  451.            implied);
  452.          larger - when the value is requested explicitly, only configs
  453.            with a corresponding attribute value that meet or exceed the
  454.            specified value are returned, with precedence given to larger
  455.            values.  When the value is not requested explicitly behaves exactly
  456.            like the ``smaller'' criterion.
  457.          exact - only configs whose corresponding attribute value exactly
  458.            matches the requested value are considered.
  459.          mask - only configs for which the set bits of corresponding
  460.            attribute include all the bits that are set in the requested
  461.            value are considered (Additional bits might be set in the
  462.            attribute).
  463.  
  464.     [Add the following to section 3.2.3 on Offscreen Rendering]
  465.  
  466.     To create a GLX pixmap using a GLXFBConfigSGIX use 
  467.  
  468.       GLXPixmap glXCreateGLXPixmapWithConfigSGIX(Display *dpy, 
  469.                                         GLXFBConfigSGIX config,
  470.                                 Pixmap pixmap);
  471.  
  472.     This call is identical to glXCreateGLXPixmap except that the GLXPixmap 
  473.     is created with color buffers and ancillary buffers as specified by 
  474.     <config>. If <config> is not a valid GLXFBConfigSGIX, or if it does not
  475.     support pixmap rendering then a GLXBadFBConfigSGIX error is generated.
  476.  
  477.  
  478.     [Add the following to section 3.2.4 on Rendering Contexts]
  479.  
  480.     To create a GLX context using a GLXFBConfigSGIX call
  481.  
  482.       GLXContext glXCreateContextWithConfigSGIX(Display *dpy,  
  483.                                                 GLXFBConfigSGIX config,
  484.                             int render_type,
  485.                         GLXContext share_list,
  486.                         Bool direct);
  487.  
  488.     This call is identical to glXCreateContext except that the resulting 
  489.     GLXContext can be used to render to any "compatible" GLXDrawable. A
  490.     GLXContext and a GLXDrawable are compatible if
  491.         - the render_type attribute for the context is supported by the
  492.           GLXFBConfigSGIX that the drawable was created with. (e.g., if the
  493.           context was created with render_type GLX_RGBA_TYPE_SGIX, then
  494.           the GLXFBConfigSGIX's GLX_RENDER_TYPE_SGIX attribute must have
  495.           the GLX_RGBA_BIT_SGIX bit set.)
  496.         - all color buffers and ancillary buffers that exist in both 
  497.       GLXFBConfigSGIXs have the same depth. For example, a GLXDrawable that 
  498.       had a front left buffer and a back left buffer with red, green and 
  499.       blue sizes of 4 would not be compatible with a GLXFBConfigSGIX that had 
  500.       only a front left buffer with red, green and blue sizes of 8. However,
  501.           it would be compatible with a GLXFBConfigSGIX that had only a front left 
  502.        buffer if the red, green and blue sizes were 4.
  503.  
  504.     glXCreateContextWithConfigSGIX can generate the following errors: 
  505.     GLXBadContext if <share_list> is neither zero nor a valid GLX
  506.     rendering context; GLXBadFBConfigSGIX if <config> is not a valid 
  507.     GLXFBConfigSGIX; BadMatch if <share_list> defines an address space that
  508.     cannot be shared with the newly created context or if <share_list>
  509.     was created on a different screen than the one referenced by <config>;
  510.     BadAlloc if the server does not have enough resources to allocate the
  511.     new context; BadValue if <render_type> does not refer to a valid
  512.     rendering type.
  513.  
  514.  
  515.     [Add to description of glXMakeCurrent]
  516.  
  517.     No error will be generated if the value of DRAW_BUFFER in <ctx> 
  518.     indicates a color buffer that is not supported by <drawable>.
  519.     In this case, all rendering will behave as if DRAW_BUFFER was 
  520.     set to NONE. The same goes for READ_BUFFER: no error will be 
  521.     generated if it does not correspond to a valid color buffer;
  522.     subsequent glReadPixel and glCopyPixel operations will simply 
  523.     return invalid data.
  524.  
  525.     Note that it is an error to later call glDrawBuffer and/or glReadBuffer
  526.     (even if they are implicitly called via glPopAttrib) and specify
  527.     a color buffer that is not supported by <drawable>.  Also
  528.     subsequent calls to glCopyPixels, that specify an unsupported
  529.     ancillary buffer, will result in an error.
  530.  
  531.     [Add to table listing GLX context attributes for glXQueryContextInfoEXT]
  532.  
  533.     GLX context attribute   type    context information
  534.     ---------------------   ----    -------------------
  535.     GLX_FBCONFIG_ID_SGIX    XID     FBConfig id
  536.  
  537.  
  538. GLX Protocol
  539.  
  540. >>> to be filled in
  541.  
  542. Dependencies on SGIS_multisample
  543.  
  544.     If SGIS_multisample is not supported, references to
  545.     GLX_SAMPLE_BUFFERS_SGIS and GLX_SAMPLES_SGIS in this document are
  546.     invalid and should be ignored.
  547.  
  548. Dependencies on EXT_visual_info
  549.  
  550.     If EXT_visual_info is not supported, references to
  551.     GLX_X_VISUAL_TYPE_EXT, GLX_TRANSPARENT_TYPE_EXT,
  552.     GLX_TRANSPARENT_INDEX_VALUE_EXT, GLX_TRANSPARENT_RED_VALUE_EXT,
  553.     GLX_TRANSPARENT_GREEN_VALUE_EXT, GLX_TRANSPARENT_BLUE_VALUE_EXT,
  554.     GLX_TRANSPARENT_ALPHA_VALUE_EXT, GLX_TRUE_COLOR_EXT, 
  555.     GLX_DIRECT_COLOR_EXT, GLX_PSEUDO_COLOR_EXT, GLX_STATIC_COLOR_EXT, 
  556.     GLX_GRAY_SCALE_EXT, and GLX_STATIC_GRAY_EXT, in this document 
  557.     are invalid and should be ignored.
  558.     
  559. Dependencies on EXT_visual_rating
  560.  
  561.     If EXT_visual_rating is not supported, references to GLX_VISUAL_CAVEAT_EXT 
  562.     and GLX_SLOW_VISUAL_EXT, in this document are invalid and should be ignored.
  563.  
  564. Dependencies on EXT_import_context
  565.  
  566.     If EXT_import_context is not supported, references to glXQueryContextInfoEXT
  567.     in this document should be ignored.
  568.  
  569. Dependencies on SGIX_pbuffer
  570.  
  571.     If SGIX_pbuffer is not supported, references to glXQueryGLXPbufferSGIX
  572.     and GLXPbuffer in this document should be ignored.
  573.  
  574.  
  575. Errors
  576.  
  577.     One new GLX error is introduced: 
  578.  
  579.     GLXBadFBConfigSGIX
  580.  
  581. New State
  582.  
  583.     None
  584.  
  585. New Implementation Dependent State
  586.  
  587.     None
  588.