| Name |
| |
| SGIX_pbuffer |
| |
| Name Strings |
| |
| GLX_SGIX_pbuffer |
| |
| Version |
| |
| Version 1.29, 2009/11/19 |
| |
| Number |
| |
| 50 |
| |
| Dependencies |
| |
| SGIX_FBConfig is required |
| SGIS_multisample affects the definition of this extension |
| |
| Overview |
| |
| This extension defines pixel buffers (GLXPbuffers, or pbuffer for |
| short). GLXPbuffers are additional non-visible rendering buffers for an |
| OpenGL renderer. GLXPbuffers are equivalent to GLXPixmaps with the |
| following exceptions: |
| |
| 1. There is no associated X pixmap. Also, since a GLXPbuffer is a GLX |
| resource, it may not be possible to render to it using X or an |
| X extension other than GLX. |
| |
| 2. The format of the color buffers and the type and size of any |
| associated ancillary buffers for a GLXPbuffer can only be |
| described with a GLXFBConfig -- an X Visual cannot be used. |
| |
| 3. It is possible to create a GLXPbuffer whose contents may be |
| asynchronously lost at any time. |
| |
| 4. GLXPbuffers can be rendered to using either direct or indirect |
| rendering contexts. |
| |
| 5. The allocation of a GLXPbuffer can fail if there are insufficient |
| resources (i.e., all the pbuffer memory has been allocated and |
| the implementation does not virtualize pbuffer memory.) |
| |
| The intent of the pbuffer semantics is to enable implementations to |
| allocate pbuffers in non-visible frame buffer memory. These |
| pbuffers are intended to be "static" resources, in that a program |
| will typically allocate them only once, rather than as a part of its |
| rendering loop. (But they should be deallocated when the program is |
| no longer using them -- for example, if the program is iconified.) |
| The frame buffer resources that are associated with a pbuffer are |
| also static, and are deallocated only when the pbuffer is destroyed, |
| or, in the case of a "unpreserved" pbuffer, as a result of X server |
| activity that changes its frame buffer requirements. |
| |
| |
| Issues |
| |
| * Should the optimum width and height be fixed sizes or a multiple? |
| |
| * Any better names for GLX_BUFFER_CLOBBER_MASK_SGIX, etc? |
| |
| UM Should we add a command so an application can set the behavior |
| when a deep window buffer (e.g., depth buffer or multisample buffer) |
| is clobbered by a pbuffer? The choices would be "preserved" or |
| "unpreserved". |
| |
| * When a pbuffer interferes with a window's ancillary buffer should |
| the action -- swapped or saved -- be specified or left as |
| implementation dependent? |
| |
| |
| New Procedures and Functions |
| |
| GLXPbuffer glXCreateGLXPbufferSGIX(Display *dpy, |
| GLXFBConfig config, |
| unsigned int width, |
| unsigned int height, |
| int *attrib_list); |
| |
| void glXDestroyGLXPbufferSGIX(Display *dpy, |
| GLXPbuffer pbuf); |
| |
| void glXQueryGLXPbufferSGIX(Display *dpy, |
| GLXPbuffer pbuf, |
| int attribute, |
| unsigned int *value); |
| |
| void glXSelectEventSGIX(Display *dpy, |
| GLXDrawable drawable, |
| unsigned long mask); |
| |
| void glXGetSelectedEventSGIX(Display *dpy, |
| GLXDrawable drawable, |
| unsigned long *mask); |
| |
| |
| New Tokens |
| |
| Accepted by the <attribute> parameter of glXGetFBConfigAttribSGIX: |
| |
| GLX_MAX_PBUFFER_WIDTH_SGIX 0x8016 |
| GLX_MAX_PBUFFER_HEIGHT_SGIX 0x8017 |
| GLX_MAX_PBUFFER_PIXELS_SGIX 0x8018 |
| GLX_OPTIMAL_PBUFFER_WIDTH_SGIX 0x8019 |
| GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX 0x801A |
| |
| 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_PBUFFER_BIT_SGIX 0x00000004 |
| |
| Accepted by the <attrib_list> parameter of glXCreateGLXPbufferSGIX |
| and by the <attribute> parameter of glXQueryGLXPbufferSGIX: |
| |
| GLX_PRESERVED_CONTENTS_SGIX 0x801B |
| GLX_LARGEST_PBUFFER_SGIX 0x801C |
| |
| Accepted by the <attribute> parameter of glXQueryGLXPbufferSGIX: |
| |
| GLX_WIDTH_SGIX 0x801D |
| GLX_HEIGHT_SGIX 0x801E |
| GLX_EVENT_MASK_SGIX 0x801F |
| |
| Accepted by the <mask> parameter of glXSelectEventSGIX and returned |
| in the <mask> parameter of glXGetSelectedEventSGIX: |
| |
| GLX_BUFFER_CLOBBER_MASK_SGIX 0x08000000 |
| |
| Returned in the <event_type> field of a "buffer clobber" event: |
| |
| GLX_DAMAGED_SGIX 0x8020 |
| GLX_SAVED_SGIX 0x8021 |
| |
| Returned in the <draw_type> field of a "buffer clobber" event: |
| |
| GLX_WINDOW_SGIX 0x8022 |
| GLX_PBUFFER_SGIX 0x8023 |
| |
| Returned in the <mask> field of a "buffer clobber" event: |
| |
| GLX_FRONT_LEFT_BUFFER_BIT_SGIX 0x00000001 |
| GLX_FRONT_RIGHT_BUFFER_BIT_SGIX 0x00000002 |
| GLX_BACK_LEFT_BUFFER_BIT_SGIX 0x00000004 |
| GLX_BACK_RIGHT_BUFFER_BIT_SGIX 0x00000008 |
| GLX_AUX_BUFFERS_BIT_SGIX 0x00000010 |
| GLX_DEPTH_BUFFER_BIT_SGIX 0x00000020 |
| GLX_STENCIL_BUFFER_BIT_SGIX 0x00000040 |
| GLX_ACCUM_BUFFER_BIT_SGIX 0x00000080 |
| GLX_SAMPLE_BUFFERS_BIT_SGIX 0x00000100 |
| |
| 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) |
| |
| None |
| |
| 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] |
| |
| [Add to glXGetFBConfigAttribSGIX]: |
| |
| GLX_MAX_PBUFFER_WIDTH_SGIX and GLX_MAX_PBUFFER_HEIGHT_SGIX indicate the |
| maximum width and height that can be passed into glXCreateGLXPbufferSGIX and |
| GLX_MAX_PBUFFER_PIXELS_SGIX indicates the maximum number of pixels (width x |
| hieght) for a GLXPbuffer. Note that an implementation may return a value for |
| GLX_MAX_PBUFFER_PIXELS_SGIX that is less than the maximum width times the |
| maximum height. Also, the value for GLX_MAX_PBUFFER_PIXELS_SGIX is static |
| and assumes that no other pbuffers or X resources are contending for the |
| framebuffer memory. Thus it may not be possible to allocate a pbuffer of |
| the size given by GLX_MAX_PBUFFER_PIXELS_SGIX. |
| |
| On some implementations, there may be an optimum width and height to use |
| when allocating a pbuffer. (For example, the implementation may use fixed |
| size tiles to allocate pbuffers.) Use GLX_OPTIMAL_PBUFFER_WIDTH_SGIX and |
| GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX to determine this width and height. If the |
| values are zero then there is no optimal value. |
| |
| [Add to glXChooseFBConfigSGIX]: |
| |
| If GLX_OPTIMAL_PBUFFER_WIDTH_SGIX and/or GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX |
| are specified in <attrib_list> then they are ignored. |
| |
| [Additions to tables 2 and 3, given in SGIX_FBConfig] |
| |
| 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 if in |
| RGB mode |
| GLX_GREEN_SIZE integer number of bits of Green if in |
| RGB mode |
| GLX_BLUE_SIZE integer number of bits of Blue if in |
| RGB mode |
| GLX_ALPHA_SIZE integer number of bits of Alpha if in |
| RGB mode |
| 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 color transparent color value. |
| GLX_TRANSPARENT_GREEN_VALUE_EXT color transparent color value. |
| GLX_TRANSPARENT_BLUE_VALUE_EXT color transparent color value. |
| GLX_TRANSPARENT_ALPHA_VALUE_EXT color transparent color 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_MAX_PBUFFER_WIDTH_SGIX integer maximum width of GLXPbuffer |
| GLX_MAX_PBUFFER_HEIGHT_SGIX integer maximum height of GLXPbuffer |
| GLX_MAX_PBUFFER_PIXELS_SGIX integer maximum size of GLXPbuffer |
| GLX_OPTIMAL_PBUFFER_WIDTH_SGIX integer best width to use when |
| creating pbuffer, or zero if |
| all widths are equally good. |
| GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX integer best height to use when creating |
| pbuffer, or zero if all |
| heights are equally good. |
| |
| Table 3: GLX configuration attributes for GLXFBConfigs (Note that |
| GLX_RGBA and GLX_USE_GL are not supported) |
| |
| Attribute Default Match Criteria |
| --------- ------- -------------- |
| GLX_BUFFER_SIZE 0 minimum |
| GLX_LEVEL 0 exact |
| GLX_DOUBLEBUFFER don't care exact |
| GLX_STEREO False exact |
| GLX_AUX_BUFFERS 0 minimum |
| GLX_RED_SIZE 0 minimum |
| GLX_GREEN_SIZE 0 minimum |
| GLX_BLUE_SIZE 0 minimum |
| GLX_ALPHA_SIZE 0 minimum |
| GLX_DEPTH_SIZE 0 minimum |
| GLX_STENCIL_SIZE 0 minimum |
| GLX_ACCUM_RED_SIZE 0 minimum |
| GLX_ACCUM_GREEN_SIZE 0 minimum |
| GLX_ACCUM_BLUE_SIZE 0 minimum |
| GLX_ACCUM_ALPHA_SIZE 0 minimum |
| GLX_SAMPLE_BUFFERS_SGIS 0 minimum |
| GLX_SAMPLES_SGIS 0 minimum |
| GLX_X_VISUAL_TYPE_EXT don't care exact |
| GLX_TRANSPARENT_PIXEL_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 minimum |
| GLX_RENDER_TYPE_SGIX GLX_RGBA_BIT_SGIX minimum |
| GLX_X_RENDERABLE_SGIX don't care exact |
| GLX_FBCONFIG_ID_SGIX don't care exact |
| GLX_MAX_PBUFFER_WIDTH_SGIX 0 minimum |
| GLX_MAX_PBUFFER_HEIGHT_SGIX 0 minimum |
| GLX_MAX_PBUFFER_PIXELS_SGIX 0 minimum |
| GLX_OPTIMAL_PBUFFER_WIDTH_SGIX ignored ignored |
| GLX_OPTIMAL_PBUFFER_HEIGHT_SGIX ignored ignored |
| |
| Table 4: Default values and match criteria for GLX configuration |
| attributes for GLXFBConfigs |
| |
| |
| [Add the following to section 3.2.3 on Offscreen Rendering] |
| |
| To create a GLXPbuffer call: |
| |
| GLXPbuffer glXCreateGLXPbufferSGIX(Display *dpy, |
| GLXFBConfig config, |
| unsigned int width, |
| unsigned int height, |
| int *attrib_list); |
| |
| This creates a single GLXPbuffer and returns its XID. <width> and <height> |
| specify the pixel width and height of the rectangular pbuffer and |
| <attrib_list> specifies a list of attributes for the pbuffer. Currently |
| only two attributes can be specified in <attrib_list>: |
| GLX_PRESERVED_CONTENTS_SGIX and GLX_LARGEST_PBUFFER_SGIX. |
| |
| <attrib_list> can be either NULL, in which case all the attributes assume |
| their default values as described below. If it not NULL then its format is |
| similar to the attribute list paramter of glXChooseFBConfigSGIX: each |
| attribute is immediately followed by the corresponding desired value and the |
| list is terminated with None. |
| |
| Use GLX_LARGEST_PBUFFER_SGIX to get the largest available pbuffer when |
| the allocation of the pbuffer would otherwise fail. The width or height |
| of the allocated pbuffer never exceed <width> and <height>, |
| respectively. Use glXQueryGLXPbufferSGIX to retrieve the dimensions of the |
| allocated pbuffer. By default, GLX_LARGEST_PBUFFER_SGIX is False. |
| |
| If the GLX_PRESERVED_CONTENTS_SGIX attribute is set to False in |
| <attrib_list>, then an "unpreserved" pbuffer is created and the contents |
| of the pbuffer may be lost at any time. If this attribute is not |
| specified, or if it is specified as True in <attrib_list>, then when a |
| resource conflict occurs the contents of the pbuffer will be preserved |
| (most likely by swapping out portions of the buffer to main memory). In |
| either case, the client can register to receive a "buffer clobber" event |
| which is generated when the pbuffer contents have been preserved or have |
| been damaged. (See the event description.) |
| |
| The resulting pbuffer will contain color buffers and ancillary as |
| specified by <config>. Note that pbuffers use framebuffer |
| resources so applications should consider deallocating them when |
| they are not in use. |
| |
| It is possible to create a pbuffer with back buffers and to swap |
| the front and back buffers by calling glXSwapBuffers. The contents |
| of the back buffers are undefined after such a swap. (Pbuffers are |
| the same as windows in this respect.) |
| |
| Any GLX rendering context created with a GLXFBConfig or X Visual that is |
| "compatible" with the <config> may be used to render into the pbuffer. (See |
| description of glXCreateContextWithConfigSGIX, glXMakeCurrent and |
| glXMakeCurrentReadSGI for definition of "compatible".) If a pbuffer is |
| created with GLX_PRESERVED_CONTENTS_SGIX set to False, then portion of the |
| buffer contents may be lost at any time due to frame buffer resource |
| conflicts. Once the contents of a "non preserved" pbuffer has been lost it |
| is considered to be in a "damaged" state. It is not an error to render to a |
| pbuffer that is in this state but the effect of rendering to it is |
| undefined. It is also not an error to query the pixel contents of such a |
| pbuffer, but the values of the returned pixels are undefined. Note, that |
| while this specification allows for non preserved pbuffers to be damaged as |
| a result of other pbuffer activity, the intent is to only have visible |
| windows activity "damage" pbuffers. |
| |
| Since the contents of a "unpreserved" pbuffer can be lost at anytime |
| with only asynchronous notification (via the "buffer clobber" event), the |
| only way a client can guarantee that valid pixels are read back with |
| glReadPixels is by grabbing the X server. (Note that this operation is |
| potentially expensive and should not be done frequently. Also, since this |
| locks out other X clients, it should only be done for short periods of |
| time.) Clients that don't wish to do this can check if the data returned |
| by glReadPixels is valid by calling XSync and then checking the event |
| queue for "buffer clobber" events (assuming that these events had been |
| pulled off of the queue prior to the glReadPixels call). |
| |
| When glXCreateGLXPbufferSGIX fails to create a GLXPbuffer due to |
| insufficient resources, a BadAlloc error is generated and None is |
| returned. If <config> is not a valid GLXFBConfig then a GLXBadFBConfigSGIX |
| error is generated; if <config> does not support GLXPbuffers then a BadMatch |
| error is generated. |
| |
| A GLXPbuffer is destroyed by calling: |
| |
| void glXDestroyGLXPbufferSGIX(Display *dpy, |
| GLXPbuffer pbuf); |
| |
| The GLXPbuffer will be destroyed once it is no longer current to any |
| client. When a GLXPbuffer is destroyed, any memory resources that are |
| attached to it are freed, and its XID is made available for reuse. |
| |
| If <pbuf> is not a valid GLXPbuffer then a GLXBadPbufferSGIX error |
| is generated. |
| |
| To query an attribute associated with a GLXPbuffer call |
| |
| void glXQueryGLXPbufferSGIX(Display* dpy, |
| GLXPbuffer pbuf, |
| int attribute, |
| unsigned int *value); |
| |
| <attribute> must be set to one of GLX_WIDTH_SGIX, GLX_HEIGHT_SGIX, |
| GLX_PRESERVED_CONTENTS_SGIX, GLX_LARGEST_PBUFFER_SGIX, or |
| GLX_FBCONFIG_ID_SGIX. |
| |
| To get the GLXFBConfig for a GLXPbuffer, first retrieve the i.d. for the |
| FBConfig and then call glXChooseFBConfigSGIX. |
| |
| If <pbuf> is not a valid GLXPbuffer then a GLXBadPbufferSGIX error is |
| generated. |
| |
| |
| [Add new section, Events] |
| |
| A client can ask to receive GLX events on a window or GLXPbuffer. |
| |
| void glXSelectEventSGIX(Display *dpy, |
| GLXDrawable drawable, |
| unsigned long mask); |
| |
| Currently only one GLX event, GLX_BUFFER_CLOBBER_MASK_SGIX, can be selected: |
| |
| typdef struct { |
| int event_type; /* GLX_DAMAGED_SGIX or GLX_SAVED_SGIX */ |
| int draw_type; /* GLX_WINDOW_SGIX or GLX_PBUFFER_SGIX */ |
| unsigned long serial; /* # of last request processed by server */ |
| Bool send_event; /* event was generated by a SendEvent request */ |
| Display *display; /* display the event was read from */ |
| GLXDrawable drawable; /* i.d. of Drawable */ |
| unsigned int mask; /* mask indicating which buffers are affected*/ |
| int x, y; |
| int width, height; |
| int count; /* if nonzero, at least this many more */ |
| } GLXBufferClobberEventSGIX; |
| |
| A single X server operation can cause several "buffer clobber" events to be |
| sent. (e.g., a single pbuffer may be damaged and cause multiple "buffer |
| clobber" events to be generated). Each event specifies one region of the |
| GLXDrawable that was affected by the X Server operation. <mask> indicates |
| which color or ancillary buffers were affected. All the "buffer clobber" |
| events generated by a single X server action are guaranteed to be contiguous |
| in the event queue. The conditions under which this event is generated and |
| the event <type> varies, depending on the type of the GLXDrawable. |
| |
| For "preserved" pbuffers, a "buffer clobber" event, with <type> |
| GLX_SAVED_SGIX, is generated whenever the contents of a pbuffer has to be |
| moved to avoid being damaged. The event(s) describes which portions of the |
| pbuffer were affected. Clients who receive many "buffer clobber" events, |
| referring to different save actions, should consider freeing the pbuffer |
| resource in order to prevent the system from thrashing due to insufficient |
| resources. |
| |
| For an "unpreserved" pbuffer a "buffer clobber" event, with <type> |
| GLX_DAMAGED_SGIX, is generated whenever a portion of the pbuffer becomes |
| invalid. |
| |
| For Windows, "buffer clobber" events, with <type> GLX_DAMAGED_SGIX or |
| GLX_SAVED_SGIX, occur whenever an ancillary buffer, associated with the |
| window, gets clobbered or moved out of offscreen memory. The event contains |
| information indicating which color or ancillary buffers, and which |
| portions of those buffers, were affected. |
| |
| Calling glXSelectEventSGIX overrides any previous event mask that was set by |
| the client for <drawable>. Note that a separate event mask is maintained for |
| each client that requested "clobber events" for <drawable>. |
| |
| If <drawable> is not a valid GLXPbuffer or a valid Window, a GLXBadDrawable |
| error is generated. |
| |
| To find out which GLX events are selected for a window or GLXPbuffer call |
| |
| void glXGetSelectedEventSGIX(Display *dpy, |
| GLXDrawable drawable, |
| unsigned long *mask); |
| |
| |
| GLX Protocol |
| |
| Four new GLX protocol commands are added. |
| |
| CreateGLXPbufferSGIX |
| 1 CARD8 opcode (X assigned) |
| 1 17 GLX opcode (glXVendorPrivateWithReply) |
| 2 8 + 2n request length |
| 4 65543 vendor specific opcode |
| 4 unused |
| 4 CARD32 screen |
| 4 GLX_FBCONFIG fbconfig |
| 4 GLX_PBUFFER pbuffer |
| 4 CARD32 width |
| 4 CARD32 height |
| 8 * n LISTofATTRIB properties |
| |
| Where n is the number of token/value pairs. Each token value is |
| either a CARD32, BOOL32, or INT32, followed by an attribute |
| value which is also either a CARD32, BOOL32, or INT32. |
| |
| |
| DestroyGLXPbufferSGIX |
| 1 CARD8 opcode (X assigned) |
| 1 17 GLX opcode (glXVendorPrivateWithReply) |
| 2 4 request length |
| 4 65544 vendor specific opcode |
| 4 unused |
| 4 GLX_PBUFFER pbuffer |
| |
| |
| ChangeDrawableAttributesSGIX |
| 1 CARD8 opcode (X assigned) |
| 1 17 GLX opcode (glXVendorPrivateWithReply) |
| 2 4 + 2*n request length |
| 4 65545 vendor specific opcode |
| 4 unused |
| 4 GLX_DRAWABLE drawable |
| 8 * n LISTofATTRIB properties |
| |
| Where n is the number of token/value pairs. Each token value is |
| either a CARD32, BOOL32, or INT32, followed by an attribute |
| value which is also either a CARD32, BOOL32, or INT32. |
| |
| |
| GetDrawableAttributesSGIX |
| 1 CARD8 opcode (X assigned) |
| 1 17 GLX opcode (glXVendorPrivateWithReply) |
| 2 4 + 2n request length |
| 4 65546 vendor specific opcode |
| 4 unused |
| 4 GLX_DRAWABLE drawable |
| => |
| 1 1 reply |
| 1 unused |
| 2 CARD16 sequence number |
| 4 2*n length |
| 4 CARD32 numAttribs |
| 20 unused |
| 8 * n LISTofATTRIB properties |
| |
| Where n is the number of token/value pairs. Each token value is |
| either a CARD32, BOOL32, or INT32, followed by an attribute |
| value which is also either a CARD32, BOOL32, or INT32. |
| |
| One new event is added: |
| |
| BEC is the base event code for the extension, as returned by |
| XQueryExtension. |
| |
| GLX_BUFFER_CLOBBER_MASK_SGIX |
| 1 BEC+16 code |
| 1 unused |
| 2 CARD16 sequence number |
| 2 CARD16 event_type |
| 0x8017 GLX_DAMAGED_SGIX |
| 0x8018 GLX_SAVED_SGIX |
| 2 CARD16 draw_type |
| 0x8019 GLX_WINDOW_SGIX |
| 0x801A GLX_PBUFFER_SGIX |
| 4 GLX_DRAWABLE drawable |
| 4 BITFIELD mask |
| 2 CARD16 x |
| 2 CARD16 y |
| 2 CARD16 width |
| 2 CARD16 height |
| 2 CARD16 count |
| 6 unused |
| |
| Dependencies on SGIS_multisample |
| |
| If SGIS_multisample is not supported, references to |
| GLX_SAMPLE_BUFFERS_BIT_SGIX in this document are invalid and should be |
| ignored. |
| |
| Errors |
| |
| One new GLX errors is introduced: |
| |
| GLXBadPbufferSGIX |
| |
| New State |
| |
| None |
| |
| New Implementation Dependent State |
| |
| None |
| |
| Revision History |
| |
| Version 1.29, 2009/11/19 - clarify that BEC in the |
| GLX_BUFFER_CLOBBER_MASK_SGIX event protocol is returned from |
| XQueryExtension, matching the GLX_ARB_create_context spec language. |
| |
| Version 1.28, 1997/03/20 - final spec as shipped by SGI. |