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