1Name 2 3 SGIX_fbconfig 4 5Name Strings 6 7 GLX_SGIX_fbconfig 8 9Version 10 11 $Date: 1997/03/24 18:56:20 $ $Revision: 1.16 $ 12 13Number 14 15 49 16 17Dependencies 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 25Overview 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 71Issues 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 106New 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 134New 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 173Additions to Chapter 2 of the 1.0 Specification (OpenGL Operation) 174 175 None 176 177Additions to Chapter 3 of the 1.0 Specification (Rasterization) 178 179 None 180 181Additions to Chapter 4 of the 1.0 Specification (Per-Fragment Operations 182and 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 194Additions to Chapter 5 of the 1.0 Specification (Special Functions) 195 196 None 197 198Additions to Chapter 6 of the 1.0 Specification (State and State Requests) 199 200 None 201 202Additions 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 538GLX Protocol 539 540 Three newGLX protocol commands are added. 541 542 GetFBConfigsSGIX 543 1 CARD8 opcode (X assigned) 544 1 17 GLX opcode (glXVendorPrivateWithReply) 545 2 4 request length 546 4 65540 vendor specific opcode 547 4 unused 548 4 CARD32 screen 549 => 550 1 1 reply 551 1 unused 552 2 CARD16 sequence number 553 4 n*m length 554 4 n numFBConfigs 555 4 m numAttribs 556 20 unused 557 8 * n LISTofATTRIB properties 558 559 Where n is the number of FBConfigs returned and m is the number 560 of attributes returned for each FBConfig. Both m and n are 561 of type CARD32. 562 563 564 CreateContextWithConfigSGIX 565 1 CARD8 opcode (X assigned) 566 1 17 GLX opcode (glXVendorPrivateWithReply) 567 2 9 request length 568 4 65541 vendor specific opcode 569 4 unused 570 4 GLX_CONTEXT context 571 4 GLX_FBCONFIG fbconfig 572 4 CARD32 screen 573 4 CARD32 renderType 574 4 GLX_CONTEXT shareList 575 1 BOOL isDirect 576 1 CARD8 reserved1 577 1 CARD16 reserved2 578 579 580 CreateGLXPixmapWithConfigSGIX 581 1 CARD8 opcode (X assigned) 582 1 17 GLX opcode (glXVendorPrivateWithReply) 583 2 7 request length 584 4 65542 vendor specific opcode 585 4 unused 586 4 CARD32 screen 587 4 GLX_FBCONFIG fbconfig 588 4 CARD32 pixmap 589 4 GLX_PIXMAP glxpixmap 590 591 592Dependencies on SGIS_multisample 593 594 If SGIS_multisample is not supported, references to 595 GLX_SAMPLE_BUFFERS_SGIS and GLX_SAMPLES_SGIS in this document are 596 invalid and should be ignored. 597 598Dependencies on EXT_visual_info 599 600 If EXT_visual_info is not supported, references to 601 GLX_X_VISUAL_TYPE_EXT, GLX_TRANSPARENT_TYPE_EXT, 602 GLX_TRANSPARENT_INDEX_VALUE_EXT, GLX_TRANSPARENT_RED_VALUE_EXT, 603 GLX_TRANSPARENT_GREEN_VALUE_EXT, GLX_TRANSPARENT_BLUE_VALUE_EXT, 604 GLX_TRANSPARENT_ALPHA_VALUE_EXT, GLX_TRUE_COLOR_EXT, 605 GLX_DIRECT_COLOR_EXT, GLX_PSEUDO_COLOR_EXT, GLX_STATIC_COLOR_EXT, 606 GLX_GRAY_SCALE_EXT, and GLX_STATIC_GRAY_EXT, in this document 607 are invalid and should be ignored. 608 609Dependencies on EXT_visual_rating 610 611 If EXT_visual_rating is not supported, references to GLX_VISUAL_CAVEAT_EXT 612 and GLX_SLOW_VISUAL_EXT, in this document are invalid and should be ignored. 613 614Dependencies on EXT_import_context 615 616 If EXT_import_context is not supported, references to glXQueryContextInfoEXT 617 in this document should be ignored. 618 619Dependencies on SGIX_pbuffer 620 621 If SGIX_pbuffer is not supported, references to glXQueryGLXPbufferSGIX 622 and GLXPbuffer in this document should be ignored. 623 624 625Errors 626 627 One new GLX error is introduced: 628 629 GLXBadFBConfigSGIX 630 631New State 632 633 None 634 635New Implementation Dependent State 636 637 None 638