1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. 5 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 23 * OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 27 /** 28 * "Fake" GLX API implemented in terms of the XMesa*() functions. 29 */ 30 31 32 33 #define GLX_GLXEXT_PROTOTYPES 34 #include "GL/glx.h" 35 36 #include <stdio.h> 37 #include <string.h> 38 #include <X11/Xmd.h> 39 #include <GL/glxproto.h> 40 41 #include "xm_api.h" 42 43 /* An "Atrribs/Attribs" typo was fixed in glxproto.h in Nov 2014. 44 * This is in case we don't have the updated header. 45 */ 46 #if !defined(X_GLXCreateContextAttribsARB) && \ 47 defined(X_GLXCreateContextAtrribsARB) 48 #define X_GLXCreateContextAttribsARB X_GLXCreateContextAtrribsARB 49 #endif 50 51 /* This indicates the client-side GLX API and GLX encoder version. */ 52 #define CLIENT_MAJOR_VERSION 1 53 #define CLIENT_MINOR_VERSION 4 /* but don't have 1.3's pbuffers, etc yet */ 54 55 /* This indicates the server-side GLX decoder version. 56 * GLX 1.4 indicates OpenGL 1.3 support 57 */ 58 #define SERVER_MAJOR_VERSION 1 59 #define SERVER_MINOR_VERSION 4 60 61 /* Who implemented this GLX? */ 62 #define VENDOR "Brian Paul" 63 64 #define EXTENSIONS \ 65 "GLX_MESA_copy_sub_buffer " \ 66 "GLX_MESA_pixmap_colormap " \ 67 "GLX_MESA_release_buffers " \ 68 "GLX_ARB_create_context " \ 69 "GLX_ARB_create_context_profile " \ 70 "GLX_ARB_get_proc_address " \ 71 "GLX_EXT_create_context_es_profile " \ 72 "GLX_EXT_create_context_es2_profile " \ 73 "GLX_EXT_texture_from_pixmap " \ 74 "GLX_EXT_visual_info " \ 75 "GLX_EXT_visual_rating " \ 76 /*"GLX_SGI_video_sync "*/ \ 77 "GLX_SGIX_fbconfig " \ 78 "GLX_SGIX_pbuffer " 79 80 #define DEFAULT_DIRECT GL_TRUE 81 82 83 /** XXX this could be based on gallium's max texture size */ 84 #define PBUFFER_MAX_SIZE 16384 85 86 87 /** 88 * The GLXContext typedef is defined as a pointer to this structure. 89 */ 90 struct __GLXcontextRec 91 { 92 Display *currentDpy; 93 GLboolean isDirect; 94 GLXDrawable currentDrawable; 95 GLXDrawable currentReadable; 96 XID xid; 97 98 XMesaContext xmesaContext; 99 }; 100 101 102 103 static pipe_tsd ContextTSD; 104 105 /** Set current context for calling thread */ 106 static void 107 SetCurrentContext(GLXContext c) 108 { 109 pipe_tsd_set(&ContextTSD, c); 110 } 111 112 /** Get current context for calling thread */ 113 static GLXContext 114 GetCurrentContext(void) 115 { 116 return pipe_tsd_get(&ContextTSD); 117 } 118 119 120 121 /**********************************************************************/ 122 /*** GLX Visual Code ***/ 123 /**********************************************************************/ 124 125 #define DONT_CARE -1 126 127 128 static XMesaVisual *VisualTable = NULL; 129 static int NumVisuals = 0; 130 131 132 133 /* Macro to handle c_class vs class field name in XVisualInfo struct */ 134 #if defined(__cplusplus) || defined(c_plusplus) 135 #define CLASS c_class 136 #else 137 #define CLASS class 138 #endif 139 140 141 142 /* 143 * Test if the given XVisualInfo is usable for Mesa rendering. 144 */ 145 static GLboolean 146 is_usable_visual( XVisualInfo *vinfo ) 147 { 148 switch (vinfo->CLASS) { 149 case StaticGray: 150 case GrayScale: 151 /* Any StaticGray/GrayScale visual works in RGB or CI mode */ 152 return GL_TRUE; 153 case StaticColor: 154 case PseudoColor: 155 /* Any StaticColor/PseudoColor visual of at least 4 bits */ 156 if (vinfo->depth>=4) { 157 return GL_TRUE; 158 } 159 else { 160 return GL_FALSE; 161 } 162 case TrueColor: 163 case DirectColor: 164 /* Any depth of TrueColor or DirectColor works in RGB mode */ 165 return GL_TRUE; 166 default: 167 /* This should never happen */ 168 return GL_FALSE; 169 } 170 } 171 172 173 /* 174 * Given an XVisualInfo and RGB, Double, and Depth buffer flags, save the 175 * configuration in our list of GLX visuals. 176 */ 177 static XMesaVisual 178 save_glx_visual( Display *dpy, XVisualInfo *vinfo, 179 GLboolean rgbFlag, GLboolean alphaFlag, GLboolean dbFlag, 180 GLboolean stereoFlag, 181 GLint depth_size, GLint stencil_size, 182 GLint accumRedSize, GLint accumGreenSize, 183 GLint accumBlueSize, GLint accumAlphaSize, 184 GLint level, GLint numAuxBuffers ) 185 { 186 GLboolean ximageFlag = GL_TRUE; 187 XMesaVisual xmvis; 188 GLint i; 189 GLboolean comparePointers; 190 191 if (dbFlag) { 192 /* Check if the MESA_BACK_BUFFER env var is set */ 193 char *backbuffer = getenv("MESA_BACK_BUFFER"); 194 if (backbuffer) { 195 if (backbuffer[0]=='p' || backbuffer[0]=='P') { 196 ximageFlag = GL_FALSE; 197 } 198 else if (backbuffer[0]=='x' || backbuffer[0]=='X') { 199 ximageFlag = GL_TRUE; 200 } 201 else { 202 _mesa_warning(NULL, "Mesa: invalid value for MESA_BACK_BUFFER environment variable, using an XImage."); 203 } 204 } 205 } 206 207 if (stereoFlag) { 208 /* stereo not supported */ 209 return NULL; 210 } 211 212 if (stencil_size > 0 && depth_size > 0) 213 depth_size = 24; 214 215 /* Comparing IDs uses less memory but sometimes fails. */ 216 /* XXX revisit this after 3.0 is finished. */ 217 if (getenv("MESA_GLX_VISUAL_HACK")) 218 comparePointers = GL_TRUE; 219 else 220 comparePointers = GL_FALSE; 221 222 /* Force the visual to have an alpha channel */ 223 if (rgbFlag && getenv("MESA_GLX_FORCE_ALPHA")) 224 alphaFlag = GL_TRUE; 225 226 /* First check if a matching visual is already in the list */ 227 for (i=0; i<NumVisuals; i++) { 228 XMesaVisual v = VisualTable[i]; 229 if (v->display == dpy 230 && v->mesa_visual.level == level 231 && v->mesa_visual.numAuxBuffers == numAuxBuffers 232 && v->ximage_flag == ximageFlag 233 && v->mesa_visual.rgbMode == rgbFlag 234 && v->mesa_visual.doubleBufferMode == dbFlag 235 && v->mesa_visual.stereoMode == stereoFlag 236 && (v->mesa_visual.alphaBits > 0) == alphaFlag 237 && (v->mesa_visual.depthBits >= depth_size || depth_size == 0) 238 && (v->mesa_visual.stencilBits >= stencil_size || stencil_size == 0) 239 && (v->mesa_visual.accumRedBits >= accumRedSize || accumRedSize == 0) 240 && (v->mesa_visual.accumGreenBits >= accumGreenSize || accumGreenSize == 0) 241 && (v->mesa_visual.accumBlueBits >= accumBlueSize || accumBlueSize == 0) 242 && (v->mesa_visual.accumAlphaBits >= accumAlphaSize || accumAlphaSize == 0)) { 243 /* now either compare XVisualInfo pointers or visual IDs */ 244 if ((!comparePointers && v->visinfo->visualid == vinfo->visualid) 245 || (comparePointers && v->vishandle == vinfo)) { 246 return v; 247 } 248 } 249 } 250 251 /* Create a new visual and add it to the list. */ 252 253 xmvis = XMesaCreateVisual( dpy, vinfo, rgbFlag, alphaFlag, dbFlag, 254 stereoFlag, ximageFlag, 255 depth_size, stencil_size, 256 accumRedSize, accumBlueSize, 257 accumBlueSize, accumAlphaSize, 0, level, 258 GLX_NONE_EXT ); 259 if (xmvis) { 260 /* Save a copy of the pointer now so we can find this visual again 261 * if we need to search for it in find_glx_visual(). 262 */ 263 xmvis->vishandle = vinfo; 264 /* Allocate more space for additional visual */ 265 VisualTable = realloc(VisualTable, sizeof(XMesaVisual) * (NumVisuals + 1)); 266 /* add xmvis to the list */ 267 VisualTable[NumVisuals] = xmvis; 268 NumVisuals++; 269 /* XXX minor hack, because XMesaCreateVisual doesn't support an 270 * aux buffers parameter. 271 */ 272 xmvis->mesa_visual.numAuxBuffers = numAuxBuffers; 273 } 274 return xmvis; 275 } 276 277 278 /** 279 * Return the default number of bits for the Z buffer. 280 * If defined, use the MESA_GLX_DEPTH_BITS env var value. 281 * Otherwise, use the DEFAULT_SOFTWARE_DEPTH_BITS constant. 282 * XXX probably do the same thing for stencil, accum, etc. 283 */ 284 static GLint 285 default_depth_bits(void) 286 { 287 int zBits; 288 const char *zEnv = getenv("MESA_GLX_DEPTH_BITS"); 289 if (zEnv) 290 zBits = atoi(zEnv); 291 else 292 zBits = 24; 293 return zBits; 294 } 295 296 static GLint 297 default_alpha_bits(void) 298 { 299 int aBits; 300 const char *aEnv = getenv("MESA_GLX_ALPHA_BITS"); 301 if (aEnv) 302 aBits = atoi(aEnv); 303 else 304 aBits = 0; 305 return aBits; 306 } 307 308 static GLint 309 default_accum_bits(void) 310 { 311 return 16; 312 } 313 314 315 316 /* 317 * Create a GLX visual from a regular XVisualInfo. 318 * This is called when Fake GLX is given an XVisualInfo which wasn't 319 * returned by glXChooseVisual. Since this is the first time we're 320 * considering this visual we'll take a guess at reasonable values 321 * for depth buffer size, stencil size, accum size, etc. 322 * This is the best we can do with a client-side emulation of GLX. 323 */ 324 static XMesaVisual 325 create_glx_visual( Display *dpy, XVisualInfo *visinfo ) 326 { 327 GLint zBits = default_depth_bits(); 328 GLint accBits = default_accum_bits(); 329 GLboolean alphaFlag = default_alpha_bits() > 0; 330 331 if (is_usable_visual( visinfo )) { 332 /* Configure this visual as RGB, double-buffered, depth-buffered. */ 333 /* This is surely wrong for some people's needs but what else */ 334 /* can be done? They should use glXChooseVisual(). */ 335 return save_glx_visual( dpy, visinfo, 336 GL_TRUE, /* rgb */ 337 alphaFlag, /* alpha */ 338 GL_TRUE, /* double */ 339 GL_FALSE, /* stereo */ 340 zBits, 341 8, /* stencil bits */ 342 accBits, /* r */ 343 accBits, /* g */ 344 accBits, /* b */ 345 accBits, /* a */ 346 0, /* level */ 347 0 /* numAux */ 348 ); 349 } 350 else { 351 _mesa_warning(NULL, "Mesa: error in glXCreateContext: bad visual\n"); 352 return NULL; 353 } 354 } 355 356 357 358 /* 359 * Find the GLX visual associated with an XVisualInfo. 360 */ 361 static XMesaVisual 362 find_glx_visual( Display *dpy, XVisualInfo *vinfo ) 363 { 364 int i; 365 366 /* try to match visual id */ 367 for (i=0;i<NumVisuals;i++) { 368 if (VisualTable[i]->display==dpy 369 && VisualTable[i]->visinfo->visualid == vinfo->visualid) { 370 return VisualTable[i]; 371 } 372 } 373 374 /* if that fails, try to match pointers */ 375 for (i=0;i<NumVisuals;i++) { 376 if (VisualTable[i]->display==dpy && VisualTable[i]->vishandle==vinfo) { 377 return VisualTable[i]; 378 } 379 } 380 381 return NULL; 382 } 383 384 385 /** 386 * Try to get an X visual which matches the given arguments. 387 */ 388 static XVisualInfo * 389 get_visual( Display *dpy, int scr, unsigned int depth, int xclass ) 390 { 391 XVisualInfo temp, *vis; 392 long mask; 393 int n; 394 unsigned int default_depth; 395 int default_class; 396 397 mask = VisualScreenMask | VisualDepthMask | VisualClassMask; 398 temp.screen = scr; 399 temp.depth = depth; 400 temp.CLASS = xclass; 401 402 default_depth = DefaultDepth(dpy,scr); 403 default_class = DefaultVisual(dpy,scr)->CLASS; 404 405 if (depth==default_depth && xclass==default_class) { 406 /* try to get root window's visual */ 407 temp.visualid = DefaultVisual(dpy,scr)->visualid; 408 mask |= VisualIDMask; 409 } 410 411 vis = XGetVisualInfo( dpy, mask, &temp, &n ); 412 413 /* In case bits/pixel > 24, make sure color channels are still <=8 bits. 414 * An SGI Infinite Reality system, for example, can have 30bpp pixels: 415 * 10 bits per color channel. Mesa's limited to a max of 8 bits/channel. 416 */ 417 if (vis && depth > 24 && (xclass==TrueColor || xclass==DirectColor)) { 418 if (_mesa_bitcount((GLuint) vis->red_mask ) <= 8 && 419 _mesa_bitcount((GLuint) vis->green_mask) <= 8 && 420 _mesa_bitcount((GLuint) vis->blue_mask ) <= 8) { 421 return vis; 422 } 423 else { 424 free((void *) vis); 425 return NULL; 426 } 427 } 428 429 return vis; 430 } 431 432 433 /* 434 * Retrieve the value of the given environment variable and find 435 * the X visual which matches it. 436 * Input: dpy - the display 437 * screen - the screen number 438 * varname - the name of the environment variable 439 * Return: an XVisualInfo pointer to NULL if error. 440 */ 441 static XVisualInfo * 442 get_env_visual(Display *dpy, int scr, const char *varname) 443 { 444 char value[100], type[100]; 445 int depth, xclass = -1; 446 XVisualInfo *vis; 447 448 if (!getenv( varname )) { 449 return NULL; 450 } 451 452 strncpy( value, getenv(varname), 100 ); 453 value[99] = 0; 454 455 sscanf( value, "%s %d", type, &depth ); 456 457 if (strcmp(type,"TrueColor")==0) xclass = TrueColor; 458 else if (strcmp(type,"DirectColor")==0) xclass = DirectColor; 459 else if (strcmp(type,"PseudoColor")==0) xclass = PseudoColor; 460 else if (strcmp(type,"StaticColor")==0) xclass = StaticColor; 461 else if (strcmp(type,"GrayScale")==0) xclass = GrayScale; 462 else if (strcmp(type,"StaticGray")==0) xclass = StaticGray; 463 464 if (xclass>-1 && depth>0) { 465 vis = get_visual( dpy, scr, depth, xclass ); 466 if (vis) { 467 return vis; 468 } 469 } 470 471 _mesa_warning(NULL, "GLX unable to find visual class=%s, depth=%d.", 472 type, depth); 473 474 return NULL; 475 } 476 477 478 479 /* 480 * Select an X visual which satisfies the RGBA flag and minimum depth. 481 * Input: dpy, 482 * screen - X display and screen number 483 * min_depth - minimum visual depth 484 * preferred_class - preferred GLX visual class or DONT_CARE 485 * Return: pointer to an XVisualInfo or NULL. 486 */ 487 static XVisualInfo * 488 choose_x_visual( Display *dpy, int screen, int min_depth, 489 int preferred_class ) 490 { 491 XVisualInfo *vis; 492 int xclass, visclass = 0; 493 int depth; 494 495 /* First see if the MESA_RGB_VISUAL env var is defined */ 496 vis = get_env_visual( dpy, screen, "MESA_RGB_VISUAL" ); 497 if (vis) { 498 return vis; 499 } 500 /* Otherwise, search for a suitable visual */ 501 if (preferred_class==DONT_CARE) { 502 for (xclass=0;xclass<6;xclass++) { 503 switch (xclass) { 504 case 0: visclass = TrueColor; break; 505 case 1: visclass = DirectColor; break; 506 case 2: visclass = PseudoColor; break; 507 case 3: visclass = StaticColor; break; 508 case 4: visclass = GrayScale; break; 509 case 5: visclass = StaticGray; break; 510 } 511 if (min_depth==0) { 512 /* start with shallowest */ 513 for (depth=0;depth<=32;depth++) { 514 if (visclass==TrueColor && depth==8) { 515 /* Special case: try to get 8-bit PseudoColor before */ 516 /* 8-bit TrueColor */ 517 vis = get_visual( dpy, screen, 8, PseudoColor ); 518 if (vis) { 519 return vis; 520 } 521 } 522 vis = get_visual( dpy, screen, depth, visclass ); 523 if (vis) { 524 return vis; 525 } 526 } 527 } 528 else { 529 /* start with deepest */ 530 for (depth=32;depth>=min_depth;depth--) { 531 if (visclass==TrueColor && depth==8) { 532 /* Special case: try to get 8-bit PseudoColor before */ 533 /* 8-bit TrueColor */ 534 vis = get_visual( dpy, screen, 8, PseudoColor ); 535 if (vis) { 536 return vis; 537 } 538 } 539 vis = get_visual( dpy, screen, depth, visclass ); 540 if (vis) { 541 return vis; 542 } 543 } 544 } 545 } 546 } 547 else { 548 /* search for a specific visual class */ 549 switch (preferred_class) { 550 case GLX_TRUE_COLOR_EXT: visclass = TrueColor; break; 551 case GLX_DIRECT_COLOR_EXT: visclass = DirectColor; break; 552 case GLX_PSEUDO_COLOR_EXT: visclass = PseudoColor; break; 553 case GLX_STATIC_COLOR_EXT: visclass = StaticColor; break; 554 case GLX_GRAY_SCALE_EXT: visclass = GrayScale; break; 555 case GLX_STATIC_GRAY_EXT: visclass = StaticGray; break; 556 default: return NULL; 557 } 558 if (min_depth==0) { 559 /* start with shallowest */ 560 for (depth=0;depth<=32;depth++) { 561 vis = get_visual( dpy, screen, depth, visclass ); 562 if (vis) { 563 return vis; 564 } 565 } 566 } 567 else { 568 /* start with deepest */ 569 for (depth=32;depth>=min_depth;depth--) { 570 vis = get_visual( dpy, screen, depth, visclass ); 571 if (vis) { 572 return vis; 573 } 574 } 575 } 576 } 577 578 /* didn't find a visual */ 579 return NULL; 580 } 581 582 583 584 585 /**********************************************************************/ 586 /*** Display-related functions ***/ 587 /**********************************************************************/ 588 589 590 /** 591 * Free all XMesaVisuals which are associated with the given display. 592 */ 593 static void 594 destroy_visuals_on_display(Display *dpy) 595 { 596 int i; 597 for (i = 0; i < NumVisuals; i++) { 598 if (VisualTable[i]->display == dpy) { 599 /* remove this visual */ 600 int j; 601 free(VisualTable[i]); 602 for (j = i; j < NumVisuals - 1; j++) 603 VisualTable[j] = VisualTable[j + 1]; 604 NumVisuals--; 605 } 606 } 607 } 608 609 610 /** 611 * Called from XCloseDisplay() to let us free our display-related data. 612 */ 613 static int 614 close_display_callback(Display *dpy, XExtCodes *codes) 615 { 616 xmesa_destroy_buffers_on_display(dpy); 617 destroy_visuals_on_display(dpy); 618 xmesa_close_display(dpy); 619 return 0; 620 } 621 622 623 /** 624 * Look for the named extension on given display and return a pointer 625 * to the _XExtension data, or NULL if extension not found. 626 */ 627 static _XExtension * 628 lookup_extension(Display *dpy, const char *extName) 629 { 630 _XExtension *ext; 631 for (ext = dpy->ext_procs; ext; ext = ext->next) { 632 if (ext->name && strcmp(ext->name, extName) == 0) { 633 return ext; 634 } 635 } 636 return NULL; 637 } 638 639 640 /** 641 * Whenever we're given a new Display pointer, call this function to 642 * register our close_display_callback function. 643 */ 644 static void 645 register_with_display(Display *dpy) 646 { 647 const char *extName = "MesaGLX"; 648 _XExtension *ext; 649 650 ext = lookup_extension(dpy, extName); 651 if (!ext) { 652 XExtCodes *c = XAddExtension(dpy); 653 ext = dpy->ext_procs; /* new extension is at head of list */ 654 assert(c->extension == ext->codes.extension); 655 (void) c; 656 ext->name = strdup(extName); 657 ext->close_display = close_display_callback; 658 } 659 } 660 661 662 /** 663 * Fake an error. 664 */ 665 static int 666 generate_error(Display *dpy, 667 unsigned char error_code, 668 XID resourceid, 669 unsigned char minor_code, 670 Bool core) 671 { 672 XErrorHandler handler; 673 int major_opcode; 674 int first_event; 675 int first_error; 676 XEvent event; 677 678 handler = XSetErrorHandler(NULL); 679 XSetErrorHandler(handler); 680 if (!handler) { 681 return 0; 682 } 683 684 if (!XQueryExtension(dpy, GLX_EXTENSION_NAME, &major_opcode, &first_event, &first_error)) { 685 major_opcode = 0; 686 first_event = 0; 687 first_error = 0; 688 } 689 690 if (!core) { 691 error_code += first_error; 692 } 693 694 memset(&event, 0, sizeof event); 695 696 event.xerror.type = X_Error; 697 event.xerror.display = dpy; 698 event.xerror.resourceid = resourceid; 699 event.xerror.serial = NextRequest(dpy) - 1; 700 event.xerror.error_code = error_code; 701 event.xerror.request_code = major_opcode; 702 event.xerror.minor_code = minor_code; 703 704 return handler(dpy, &event.xerror); 705 } 706 707 708 /**********************************************************************/ 709 /*** Begin Fake GLX API Functions ***/ 710 /**********************************************************************/ 711 712 713 /** 714 * Helper used by glXChooseVisual and glXChooseFBConfig. 715 * The fbConfig parameter must be GL_FALSE for the former and GL_TRUE for 716 * the later. 717 * In either case, the attribute list is terminated with the value 'None'. 718 */ 719 static XMesaVisual 720 choose_visual( Display *dpy, int screen, const int *list, GLboolean fbConfig ) 721 { 722 const GLboolean rgbModeDefault = fbConfig; 723 const int *parselist; 724 XVisualInfo *vis; 725 int min_red=0, min_green=0, min_blue=0; 726 GLboolean rgb_flag = rgbModeDefault; 727 GLboolean alpha_flag = GL_FALSE; 728 GLboolean double_flag = GL_FALSE; 729 GLboolean stereo_flag = GL_FALSE; 730 GLint depth_size = 0; 731 GLint stencil_size = 0; 732 GLint accumRedSize = 0; 733 GLint accumGreenSize = 0; 734 GLint accumBlueSize = 0; 735 GLint accumAlphaSize = 0; 736 int level = 0; 737 int visual_type = DONT_CARE; 738 GLint caveat = DONT_CARE; 739 XMesaVisual xmvis = NULL; 740 int desiredVisualID = -1; 741 int numAux = 0; 742 743 xmesa_init( dpy ); 744 745 parselist = list; 746 747 while (*parselist) { 748 749 if (fbConfig && 750 parselist[1] == GLX_DONT_CARE && 751 parselist[0] != GLX_LEVEL) { 752 /* For glXChooseFBConfig(), skip attributes whose value is 753 * GLX_DONT_CARE, unless it's GLX_LEVEL (which can legitimately be 754 * a negative value). 755 * 756 * From page 17 (23 of the pdf) of the GLX 1.4 spec: 757 * GLX DONT CARE may be specified for all attributes except GLX LEVEL. 758 */ 759 parselist += 2; 760 continue; 761 } 762 763 switch (*parselist) { 764 case GLX_USE_GL: 765 if (fbConfig) { 766 /* invalid token */ 767 return NULL; 768 } 769 else { 770 /* skip */ 771 parselist++; 772 } 773 break; 774 case GLX_BUFFER_SIZE: 775 parselist++; 776 parselist++; 777 break; 778 case GLX_LEVEL: 779 parselist++; 780 level = *parselist++; 781 break; 782 case GLX_RGBA: 783 if (fbConfig) { 784 /* invalid token */ 785 return NULL; 786 } 787 else { 788 rgb_flag = GL_TRUE; 789 parselist++; 790 } 791 break; 792 case GLX_DOUBLEBUFFER: 793 parselist++; 794 if (fbConfig) { 795 double_flag = *parselist++; 796 } 797 else { 798 double_flag = GL_TRUE; 799 } 800 break; 801 case GLX_STEREO: 802 parselist++; 803 if (fbConfig) { 804 stereo_flag = *parselist++; 805 } 806 else { 807 stereo_flag = GL_TRUE; 808 } 809 break; 810 case GLX_AUX_BUFFERS: 811 parselist++; 812 numAux = *parselist++; 813 if (numAux > MAX_AUX_BUFFERS) 814 return NULL; 815 break; 816 case GLX_RED_SIZE: 817 parselist++; 818 min_red = *parselist++; 819 break; 820 case GLX_GREEN_SIZE: 821 parselist++; 822 min_green = *parselist++; 823 break; 824 case GLX_BLUE_SIZE: 825 parselist++; 826 min_blue = *parselist++; 827 break; 828 case GLX_ALPHA_SIZE: 829 parselist++; 830 { 831 GLint size = *parselist++; 832 alpha_flag = size ? GL_TRUE : GL_FALSE; 833 } 834 break; 835 case GLX_DEPTH_SIZE: 836 parselist++; 837 depth_size = *parselist++; 838 break; 839 case GLX_STENCIL_SIZE: 840 parselist++; 841 stencil_size = *parselist++; 842 break; 843 case GLX_ACCUM_RED_SIZE: 844 parselist++; 845 { 846 GLint size = *parselist++; 847 accumRedSize = MAX2( accumRedSize, size ); 848 } 849 break; 850 case GLX_ACCUM_GREEN_SIZE: 851 parselist++; 852 { 853 GLint size = *parselist++; 854 accumGreenSize = MAX2( accumGreenSize, size ); 855 } 856 break; 857 case GLX_ACCUM_BLUE_SIZE: 858 parselist++; 859 { 860 GLint size = *parselist++; 861 accumBlueSize = MAX2( accumBlueSize, size ); 862 } 863 break; 864 case GLX_ACCUM_ALPHA_SIZE: 865 parselist++; 866 { 867 GLint size = *parselist++; 868 accumAlphaSize = MAX2( accumAlphaSize, size ); 869 } 870 break; 871 872 /* 873 * GLX_EXT_visual_info extension 874 */ 875 case GLX_X_VISUAL_TYPE_EXT: 876 parselist++; 877 visual_type = *parselist++; 878 break; 879 case GLX_TRANSPARENT_TYPE_EXT: 880 parselist++; 881 parselist++; 882 break; 883 case GLX_TRANSPARENT_INDEX_VALUE_EXT: 884 parselist++; 885 parselist++; 886 break; 887 case GLX_TRANSPARENT_RED_VALUE_EXT: 888 case GLX_TRANSPARENT_GREEN_VALUE_EXT: 889 case GLX_TRANSPARENT_BLUE_VALUE_EXT: 890 case GLX_TRANSPARENT_ALPHA_VALUE_EXT: 891 /* ignore */ 892 parselist++; 893 parselist++; 894 break; 895 896 /* 897 * GLX_EXT_visual_info extension 898 */ 899 case GLX_VISUAL_CAVEAT_EXT: 900 parselist++; 901 caveat = *parselist++; /* ignored for now */ 902 break; 903 904 /* 905 * GLX_ARB_multisample 906 */ 907 case GLX_SAMPLE_BUFFERS_ARB: 908 case GLX_SAMPLES_ARB: 909 parselist++; 910 if (*parselist++ != 0) { 911 /* ms not supported */ 912 return NULL; 913 } 914 break; 915 916 /* 917 * FBConfig attribs. 918 */ 919 case GLX_RENDER_TYPE: 920 if (!fbConfig) 921 return NULL; 922 parselist++; 923 if (*parselist & GLX_RGBA_BIT) { 924 rgb_flag = GL_TRUE; 925 } 926 else if (*parselist & GLX_COLOR_INDEX_BIT) { 927 rgb_flag = GL_FALSE; 928 } 929 else if (*parselist == 0) { 930 rgb_flag = GL_TRUE; 931 } 932 parselist++; 933 break; 934 case GLX_DRAWABLE_TYPE: 935 if (!fbConfig) 936 return NULL; 937 parselist++; 938 if (*parselist & ~(GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT)) { 939 return NULL; /* bad bit */ 940 } 941 parselist++; 942 break; 943 case GLX_FBCONFIG_ID: 944 case GLX_VISUAL_ID: 945 if (!fbConfig) 946 return NULL; 947 parselist++; 948 desiredVisualID = *parselist++; 949 break; 950 case GLX_X_RENDERABLE: 951 case GLX_MAX_PBUFFER_WIDTH: 952 case GLX_MAX_PBUFFER_HEIGHT: 953 case GLX_MAX_PBUFFER_PIXELS: 954 if (!fbConfig) 955 return NULL; /* invalid config option */ 956 parselist += 2; /* ignore the parameter */ 957 break; 958 959 #ifdef GLX_EXT_texture_from_pixmap 960 case GLX_BIND_TO_TEXTURE_RGB_EXT: 961 parselist++; /*skip*/ 962 break; 963 case GLX_BIND_TO_TEXTURE_RGBA_EXT: 964 parselist++; /*skip*/ 965 break; 966 case GLX_BIND_TO_MIPMAP_TEXTURE_EXT: 967 parselist++; /*skip*/ 968 break; 969 case GLX_BIND_TO_TEXTURE_TARGETS_EXT: 970 parselist++; 971 if (*parselist & ~(GLX_TEXTURE_1D_BIT_EXT | 972 GLX_TEXTURE_2D_BIT_EXT | 973 GLX_TEXTURE_RECTANGLE_BIT_EXT)) { 974 /* invalid bit */ 975 return NULL; 976 } 977 break; 978 case GLX_Y_INVERTED_EXT: 979 parselist++; /*skip*/ 980 break; 981 #endif 982 983 case None: 984 /* end of list */ 985 break; 986 987 default: 988 /* undefined attribute */ 989 _mesa_warning(NULL, "unexpected attrib 0x%x in choose_visual()", 990 *parselist); 991 return NULL; 992 } 993 } 994 995 (void) caveat; 996 997 998 /* 999 * Since we're only simulating the GLX extension this function will never 1000 * find any real GL visuals. Instead, all we can do is try to find an RGB 1001 * or CI visual of appropriate depth. Other requested attributes such as 1002 * double buffering, depth buffer, etc. will be associated with the X 1003 * visual and stored in the VisualTable[]. 1004 */ 1005 if (desiredVisualID != -1) { 1006 /* try to get a specific visual, by visualID */ 1007 XVisualInfo temp; 1008 int n; 1009 temp.visualid = desiredVisualID; 1010 temp.screen = screen; 1011 vis = XGetVisualInfo(dpy, VisualIDMask | VisualScreenMask, &temp, &n); 1012 if (vis) { 1013 /* give the visual some useful GLX attributes */ 1014 double_flag = GL_TRUE; 1015 rgb_flag = GL_TRUE; 1016 } 1017 } 1018 else if (level==0) { 1019 /* normal color planes */ 1020 /* Get an RGB visual */ 1021 int min_rgb = min_red + min_green + min_blue; 1022 if (min_rgb>1 && min_rgb<8) { 1023 /* a special case to be sure we can get a monochrome visual */ 1024 min_rgb = 1; 1025 } 1026 vis = choose_x_visual( dpy, screen, min_rgb, visual_type ); 1027 } 1028 else { 1029 _mesa_warning(NULL, "overlay not supported"); 1030 return NULL; 1031 } 1032 1033 if (vis) { 1034 /* Note: we're not exactly obeying the glXChooseVisual rules here. 1035 * When GLX_DEPTH_SIZE = 1 is specified we're supposed to choose the 1036 * largest depth buffer size, which is 32bits/value. Instead, we 1037 * return 16 to maintain performance with earlier versions of Mesa. 1038 */ 1039 if (stencil_size > 0) 1040 depth_size = 24; /* if Z and stencil, always use 24+8 format */ 1041 else if (depth_size > 24) 1042 depth_size = 32; 1043 else if (depth_size > 16) 1044 depth_size = 24; 1045 else if (depth_size > 0) { 1046 depth_size = default_depth_bits(); 1047 } 1048 1049 if (!alpha_flag) { 1050 alpha_flag = default_alpha_bits() > 0; 1051 } 1052 1053 /* we only support one size of stencil and accum buffers. */ 1054 if (stencil_size > 0) 1055 stencil_size = 8; 1056 1057 if (accumRedSize > 0 || 1058 accumGreenSize > 0 || 1059 accumBlueSize > 0 || 1060 accumAlphaSize > 0) { 1061 1062 accumRedSize = 1063 accumGreenSize = 1064 accumBlueSize = default_accum_bits(); 1065 1066 accumAlphaSize = alpha_flag ? accumRedSize : 0; 1067 } 1068 1069 xmvis = save_glx_visual( dpy, vis, rgb_flag, alpha_flag, double_flag, 1070 stereo_flag, depth_size, stencil_size, 1071 accumRedSize, accumGreenSize, 1072 accumBlueSize, accumAlphaSize, level, numAux ); 1073 } 1074 1075 return xmvis; 1076 } 1077 1078 1079 PUBLIC XVisualInfo * 1080 glXChooseVisual( Display *dpy, int screen, int *list ) 1081 { 1082 XMesaVisual xmvis; 1083 1084 /* register ourselves as an extension on this display */ 1085 register_with_display(dpy); 1086 1087 xmvis = choose_visual(dpy, screen, list, GL_FALSE); 1088 if (xmvis) { 1089 /* create a new vishandle - the cached one may be stale */ 1090 xmvis->vishandle = malloc(sizeof(XVisualInfo)); 1091 if (xmvis->vishandle) { 1092 memcpy(xmvis->vishandle, xmvis->visinfo, sizeof(XVisualInfo)); 1093 } 1094 return xmvis->vishandle; 1095 } 1096 else 1097 return NULL; 1098 } 1099 1100 1101 /** 1102 * Helper function used by other glXCreateContext functions. 1103 */ 1104 static GLXContext 1105 create_context(Display *dpy, XMesaVisual xmvis, 1106 XMesaContext shareCtx, Bool direct, 1107 unsigned major, unsigned minor, 1108 unsigned profileMask, unsigned contextFlags) 1109 { 1110 GLXContext glxCtx; 1111 1112 if (!dpy || !xmvis) 1113 return 0; 1114 1115 glxCtx = CALLOC_STRUCT(__GLXcontextRec); 1116 if (!glxCtx) 1117 return 0; 1118 1119 /* deallocate unused windows/buffers */ 1120 #if 0 1121 XMesaGarbageCollect(); 1122 #endif 1123 1124 glxCtx->xmesaContext = XMesaCreateContext(xmvis, shareCtx, major, minor, 1125 profileMask, contextFlags); 1126 if (!glxCtx->xmesaContext) { 1127 free(glxCtx); 1128 return NULL; 1129 } 1130 1131 glxCtx->isDirect = DEFAULT_DIRECT; 1132 glxCtx->currentDpy = dpy; 1133 glxCtx->xid = (XID) glxCtx; /* self pointer */ 1134 1135 return glxCtx; 1136 } 1137 1138 1139 PUBLIC GLXContext 1140 glXCreateContext( Display *dpy, XVisualInfo *visinfo, 1141 GLXContext shareCtx, Bool direct ) 1142 { 1143 XMesaVisual xmvis; 1144 1145 xmvis = find_glx_visual( dpy, visinfo ); 1146 if (!xmvis) { 1147 /* This visual wasn't found with glXChooseVisual() */ 1148 xmvis = create_glx_visual( dpy, visinfo ); 1149 if (!xmvis) { 1150 /* unusable visual */ 1151 return NULL; 1152 } 1153 } 1154 1155 return create_context(dpy, xmvis, 1156 shareCtx ? shareCtx->xmesaContext : NULL, 1157 direct, 1158 1, 0, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 0x0); 1159 } 1160 1161 1162 /* XXX these may have to be removed due to thread-safety issues. */ 1163 static GLXContext MakeCurrent_PrevContext = 0; 1164 static GLXDrawable MakeCurrent_PrevDrawable = 0; 1165 static GLXDrawable MakeCurrent_PrevReadable = 0; 1166 static XMesaBuffer MakeCurrent_PrevDrawBuffer = 0; 1167 static XMesaBuffer MakeCurrent_PrevReadBuffer = 0; 1168 1169 1170 /* GLX 1.3 and later */ 1171 PUBLIC Bool 1172 glXMakeContextCurrent( Display *dpy, GLXDrawable draw, 1173 GLXDrawable read, GLXContext ctx ) 1174 { 1175 GLXContext glxCtx = ctx; 1176 static boolean firsttime = 1, no_rast = 0; 1177 1178 if (firsttime) { 1179 no_rast = getenv("SP_NO_RAST") != NULL; 1180 firsttime = 0; 1181 } 1182 1183 if (ctx && draw && read) { 1184 XMesaBuffer drawBuffer, readBuffer; 1185 XMesaContext xmctx = glxCtx->xmesaContext; 1186 1187 /* Find the XMesaBuffer which corresponds to the GLXDrawable 'draw' */ 1188 if (ctx == MakeCurrent_PrevContext 1189 && draw == MakeCurrent_PrevDrawable) { 1190 drawBuffer = MakeCurrent_PrevDrawBuffer; 1191 } 1192 else { 1193 drawBuffer = XMesaFindBuffer( dpy, draw ); 1194 } 1195 if (!drawBuffer) { 1196 /* drawable must be a new window! */ 1197 drawBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, draw ); 1198 if (!drawBuffer) { 1199 /* Out of memory, or context/drawable depth mismatch */ 1200 return False; 1201 } 1202 } 1203 1204 /* Find the XMesaBuffer which corresponds to the GLXDrawable 'read' */ 1205 if (ctx == MakeCurrent_PrevContext 1206 && read == MakeCurrent_PrevReadable) { 1207 readBuffer = MakeCurrent_PrevReadBuffer; 1208 } 1209 else { 1210 readBuffer = XMesaFindBuffer( dpy, read ); 1211 } 1212 if (!readBuffer) { 1213 /* drawable must be a new window! */ 1214 readBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, read ); 1215 if (!readBuffer) { 1216 /* Out of memory, or context/drawable depth mismatch */ 1217 return False; 1218 } 1219 } 1220 1221 if (no_rast && 1222 MakeCurrent_PrevContext == ctx && 1223 MakeCurrent_PrevDrawable == draw && 1224 MakeCurrent_PrevReadable == read && 1225 MakeCurrent_PrevDrawBuffer == drawBuffer && 1226 MakeCurrent_PrevReadBuffer == readBuffer) 1227 return True; 1228 1229 MakeCurrent_PrevContext = ctx; 1230 MakeCurrent_PrevDrawable = draw; 1231 MakeCurrent_PrevReadable = read; 1232 MakeCurrent_PrevDrawBuffer = drawBuffer; 1233 MakeCurrent_PrevReadBuffer = readBuffer; 1234 1235 /* Now make current! */ 1236 if (XMesaMakeCurrent2(xmctx, drawBuffer, readBuffer)) { 1237 ctx->currentDpy = dpy; 1238 ctx->currentDrawable = draw; 1239 ctx->currentReadable = read; 1240 SetCurrentContext(ctx); 1241 return True; 1242 } 1243 else { 1244 return False; 1245 } 1246 } 1247 else if (!ctx && !draw && !read) { 1248 /* release current context w/out assigning new one. */ 1249 XMesaMakeCurrent2( NULL, NULL, NULL ); 1250 MakeCurrent_PrevContext = 0; 1251 MakeCurrent_PrevDrawable = 0; 1252 MakeCurrent_PrevReadable = 0; 1253 MakeCurrent_PrevDrawBuffer = 0; 1254 MakeCurrent_PrevReadBuffer = 0; 1255 SetCurrentContext(NULL); 1256 return True; 1257 } 1258 else { 1259 /* The args must either all be non-zero or all zero. 1260 * This is an error. 1261 */ 1262 return False; 1263 } 1264 } 1265 1266 1267 PUBLIC Bool 1268 glXMakeCurrent( Display *dpy, GLXDrawable drawable, GLXContext ctx ) 1269 { 1270 return glXMakeContextCurrent( dpy, drawable, drawable, ctx ); 1271 } 1272 1273 1274 PUBLIC GLXContext 1275 glXGetCurrentContext(void) 1276 { 1277 return GetCurrentContext(); 1278 } 1279 1280 1281 PUBLIC Display * 1282 glXGetCurrentDisplay(void) 1283 { 1284 GLXContext glxCtx = glXGetCurrentContext(); 1285 1286 return glxCtx ? glxCtx->currentDpy : NULL; 1287 } 1288 1289 1290 PUBLIC Display * 1291 glXGetCurrentDisplayEXT(void) 1292 { 1293 return glXGetCurrentDisplay(); 1294 } 1295 1296 1297 PUBLIC GLXDrawable 1298 glXGetCurrentDrawable(void) 1299 { 1300 GLXContext gc = glXGetCurrentContext(); 1301 return gc ? gc->currentDrawable : 0; 1302 } 1303 1304 1305 PUBLIC GLXDrawable 1306 glXGetCurrentReadDrawable(void) 1307 { 1308 GLXContext gc = glXGetCurrentContext(); 1309 return gc ? gc->currentReadable : 0; 1310 } 1311 1312 1313 PUBLIC GLXDrawable 1314 glXGetCurrentReadDrawableSGI(void) 1315 { 1316 return glXGetCurrentReadDrawable(); 1317 } 1318 1319 1320 PUBLIC GLXPixmap 1321 glXCreateGLXPixmap( Display *dpy, XVisualInfo *visinfo, Pixmap pixmap ) 1322 { 1323 XMesaVisual v; 1324 XMesaBuffer b; 1325 1326 v = find_glx_visual( dpy, visinfo ); 1327 if (!v) { 1328 v = create_glx_visual( dpy, visinfo ); 1329 if (!v) { 1330 /* unusable visual */ 1331 return 0; 1332 } 1333 } 1334 1335 b = XMesaCreatePixmapBuffer( v, pixmap, 0 ); 1336 if (!b) { 1337 return 0; 1338 } 1339 return b->ws.drawable; 1340 } 1341 1342 1343 /*** GLX_MESA_pixmap_colormap ***/ 1344 1345 PUBLIC GLXPixmap 1346 glXCreateGLXPixmapMESA( Display *dpy, XVisualInfo *visinfo, 1347 Pixmap pixmap, Colormap cmap ) 1348 { 1349 XMesaVisual v; 1350 XMesaBuffer b; 1351 1352 v = find_glx_visual( dpy, visinfo ); 1353 if (!v) { 1354 v = create_glx_visual( dpy, visinfo ); 1355 if (!v) { 1356 /* unusable visual */ 1357 return 0; 1358 } 1359 } 1360 1361 b = XMesaCreatePixmapBuffer( v, pixmap, cmap ); 1362 if (!b) { 1363 return 0; 1364 } 1365 return b->ws.drawable; 1366 } 1367 1368 1369 PUBLIC void 1370 glXDestroyGLXPixmap( Display *dpy, GLXPixmap pixmap ) 1371 { 1372 XMesaBuffer b = XMesaFindBuffer(dpy, pixmap); 1373 if (b) { 1374 XMesaDestroyBuffer(b); 1375 } 1376 else if (getenv("MESA_DEBUG")) { 1377 _mesa_warning(NULL, "Mesa: glXDestroyGLXPixmap: invalid pixmap\n"); 1378 } 1379 } 1380 1381 1382 PUBLIC void 1383 glXCopyContext( Display *dpy, GLXContext src, GLXContext dst, 1384 unsigned long mask ) 1385 { 1386 XMesaContext xm_src = src->xmesaContext; 1387 XMesaContext xm_dst = dst->xmesaContext; 1388 (void) dpy; 1389 if (MakeCurrent_PrevContext == src) { 1390 glFlush(); 1391 } 1392 XMesaCopyContext(xm_src, xm_dst, mask); 1393 } 1394 1395 1396 PUBLIC Bool 1397 glXQueryExtension( Display *dpy, int *errorBase, int *eventBase ) 1398 { 1399 int op, ev, err; 1400 /* Mesa's GLX isn't really an X extension but we try to act like one. */ 1401 if (!XQueryExtension(dpy, GLX_EXTENSION_NAME, &op, &ev, &err)) 1402 ev = err = 0; 1403 if (errorBase) 1404 *errorBase = err; 1405 if (eventBase) 1406 *eventBase = ev; 1407 return True; /* we're faking GLX so always return success */ 1408 } 1409 1410 1411 PUBLIC void 1412 glXDestroyContext( Display *dpy, GLXContext ctx ) 1413 { 1414 if (ctx) { 1415 GLXContext glxCtx = ctx; 1416 (void) dpy; 1417 MakeCurrent_PrevContext = 0; 1418 MakeCurrent_PrevDrawable = 0; 1419 MakeCurrent_PrevReadable = 0; 1420 MakeCurrent_PrevDrawBuffer = 0; 1421 MakeCurrent_PrevReadBuffer = 0; 1422 XMesaDestroyContext( glxCtx->xmesaContext ); 1423 XMesaGarbageCollect(); 1424 free(glxCtx); 1425 } 1426 } 1427 1428 1429 PUBLIC Bool 1430 glXIsDirect( Display *dpy, GLXContext ctx ) 1431 { 1432 return ctx ? ctx->isDirect : False; 1433 } 1434 1435 1436 1437 PUBLIC void 1438 glXSwapBuffers( Display *dpy, GLXDrawable drawable ) 1439 { 1440 XMesaBuffer buffer = XMesaFindBuffer( dpy, drawable ); 1441 static boolean firsttime = 1, no_rast = 0; 1442 1443 if (firsttime) { 1444 no_rast = getenv("SP_NO_RAST") != NULL; 1445 firsttime = 0; 1446 } 1447 1448 if (no_rast) 1449 return; 1450 1451 if (buffer) { 1452 XMesaSwapBuffers(buffer); 1453 } 1454 else if (getenv("MESA_DEBUG")) { 1455 _mesa_warning(NULL, "glXSwapBuffers: invalid drawable 0x%x\n", 1456 (int) drawable); 1457 } 1458 } 1459 1460 1461 1462 /*** GLX_MESA_copy_sub_buffer ***/ 1463 1464 PUBLIC void 1465 glXCopySubBufferMESA(Display *dpy, GLXDrawable drawable, 1466 int x, int y, int width, int height) 1467 { 1468 XMesaBuffer buffer = XMesaFindBuffer( dpy, drawable ); 1469 if (buffer) { 1470 XMesaCopySubBuffer(buffer, x, y, width, height); 1471 } 1472 else if (getenv("MESA_DEBUG")) { 1473 _mesa_warning(NULL, "Mesa: glXCopySubBufferMESA: invalid drawable\n"); 1474 } 1475 } 1476 1477 1478 PUBLIC Bool 1479 glXQueryVersion( Display *dpy, int *maj, int *min ) 1480 { 1481 (void) dpy; 1482 /* Return GLX version, not Mesa version */ 1483 assert(CLIENT_MAJOR_VERSION == SERVER_MAJOR_VERSION); 1484 *maj = CLIENT_MAJOR_VERSION; 1485 *min = MIN2( CLIENT_MINOR_VERSION, SERVER_MINOR_VERSION ); 1486 return True; 1487 } 1488 1489 1490 /* 1491 * Query the GLX attributes of the given XVisualInfo. 1492 */ 1493 static int 1494 get_config( XMesaVisual xmvis, int attrib, int *value, GLboolean fbconfig ) 1495 { 1496 assert(xmvis); 1497 switch(attrib) { 1498 case GLX_USE_GL: 1499 if (fbconfig) 1500 return GLX_BAD_ATTRIBUTE; 1501 *value = (int) True; 1502 return 0; 1503 case GLX_BUFFER_SIZE: 1504 *value = xmvis->visinfo->depth; 1505 return 0; 1506 case GLX_LEVEL: 1507 *value = xmvis->mesa_visual.level; 1508 return 0; 1509 case GLX_RGBA: 1510 if (fbconfig) 1511 return GLX_BAD_ATTRIBUTE; 1512 if (xmvis->mesa_visual.rgbMode) { 1513 *value = True; 1514 } 1515 else { 1516 *value = False; 1517 } 1518 return 0; 1519 case GLX_DOUBLEBUFFER: 1520 *value = (int) xmvis->mesa_visual.doubleBufferMode; 1521 return 0; 1522 case GLX_STEREO: 1523 *value = (int) xmvis->mesa_visual.stereoMode; 1524 return 0; 1525 case GLX_AUX_BUFFERS: 1526 *value = xmvis->mesa_visual.numAuxBuffers; 1527 return 0; 1528 case GLX_RED_SIZE: 1529 *value = xmvis->mesa_visual.redBits; 1530 return 0; 1531 case GLX_GREEN_SIZE: 1532 *value = xmvis->mesa_visual.greenBits; 1533 return 0; 1534 case GLX_BLUE_SIZE: 1535 *value = xmvis->mesa_visual.blueBits; 1536 return 0; 1537 case GLX_ALPHA_SIZE: 1538 *value = xmvis->mesa_visual.alphaBits; 1539 return 0; 1540 case GLX_DEPTH_SIZE: 1541 *value = xmvis->mesa_visual.depthBits; 1542 return 0; 1543 case GLX_STENCIL_SIZE: 1544 *value = xmvis->mesa_visual.stencilBits; 1545 return 0; 1546 case GLX_ACCUM_RED_SIZE: 1547 *value = xmvis->mesa_visual.accumRedBits; 1548 return 0; 1549 case GLX_ACCUM_GREEN_SIZE: 1550 *value = xmvis->mesa_visual.accumGreenBits; 1551 return 0; 1552 case GLX_ACCUM_BLUE_SIZE: 1553 *value = xmvis->mesa_visual.accumBlueBits; 1554 return 0; 1555 case GLX_ACCUM_ALPHA_SIZE: 1556 *value = xmvis->mesa_visual.accumAlphaBits; 1557 return 0; 1558 1559 /* 1560 * GLX_EXT_visual_info extension 1561 */ 1562 case GLX_X_VISUAL_TYPE_EXT: 1563 switch (xmvis->visinfo->CLASS) { 1564 case StaticGray: *value = GLX_STATIC_GRAY_EXT; return 0; 1565 case GrayScale: *value = GLX_GRAY_SCALE_EXT; return 0; 1566 case StaticColor: *value = GLX_STATIC_GRAY_EXT; return 0; 1567 case PseudoColor: *value = GLX_PSEUDO_COLOR_EXT; return 0; 1568 case TrueColor: *value = GLX_TRUE_COLOR_EXT; return 0; 1569 case DirectColor: *value = GLX_DIRECT_COLOR_EXT; return 0; 1570 } 1571 return 0; 1572 case GLX_TRANSPARENT_TYPE_EXT: 1573 /* normal planes */ 1574 *value = GLX_NONE_EXT; 1575 return 0; 1576 case GLX_TRANSPARENT_INDEX_VALUE_EXT: 1577 /* undefined */ 1578 return 0; 1579 case GLX_TRANSPARENT_RED_VALUE_EXT: 1580 /* undefined */ 1581 return 0; 1582 case GLX_TRANSPARENT_GREEN_VALUE_EXT: 1583 /* undefined */ 1584 return 0; 1585 case GLX_TRANSPARENT_BLUE_VALUE_EXT: 1586 /* undefined */ 1587 return 0; 1588 case GLX_TRANSPARENT_ALPHA_VALUE_EXT: 1589 /* undefined */ 1590 return 0; 1591 1592 /* 1593 * GLX_EXT_visual_info extension 1594 */ 1595 case GLX_VISUAL_CAVEAT_EXT: 1596 /* test for zero, just in case */ 1597 if (xmvis->mesa_visual.visualRating > 0) 1598 *value = xmvis->mesa_visual.visualRating; 1599 else 1600 *value = GLX_NONE_EXT; 1601 return 0; 1602 1603 /* 1604 * GLX_ARB_multisample 1605 */ 1606 case GLX_SAMPLE_BUFFERS_ARB: 1607 *value = 0; 1608 return 0; 1609 case GLX_SAMPLES_ARB: 1610 *value = 0; 1611 return 0; 1612 1613 /* 1614 * For FBConfigs: 1615 */ 1616 case GLX_SCREEN_EXT: 1617 if (!fbconfig) 1618 return GLX_BAD_ATTRIBUTE; 1619 *value = xmvis->visinfo->screen; 1620 break; 1621 case GLX_DRAWABLE_TYPE: /*SGIX too */ 1622 if (!fbconfig) 1623 return GLX_BAD_ATTRIBUTE; 1624 *value = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT; 1625 break; 1626 case GLX_RENDER_TYPE_SGIX: 1627 if (!fbconfig) 1628 return GLX_BAD_ATTRIBUTE; 1629 if (xmvis->mesa_visual.rgbMode) 1630 *value = GLX_RGBA_BIT; 1631 else 1632 *value = GLX_COLOR_INDEX_BIT; 1633 break; 1634 case GLX_X_RENDERABLE_SGIX: 1635 if (!fbconfig) 1636 return GLX_BAD_ATTRIBUTE; 1637 *value = True; /* XXX really? */ 1638 break; 1639 case GLX_FBCONFIG_ID_SGIX: 1640 if (!fbconfig) 1641 return GLX_BAD_ATTRIBUTE; 1642 *value = xmvis->visinfo->visualid; 1643 break; 1644 case GLX_MAX_PBUFFER_WIDTH: 1645 if (!fbconfig) 1646 return GLX_BAD_ATTRIBUTE; 1647 /* XXX should be same as ctx->Const.MaxRenderbufferSize */ 1648 *value = DisplayWidth(xmvis->display, xmvis->visinfo->screen); 1649 break; 1650 case GLX_MAX_PBUFFER_HEIGHT: 1651 if (!fbconfig) 1652 return GLX_BAD_ATTRIBUTE; 1653 *value = DisplayHeight(xmvis->display, xmvis->visinfo->screen); 1654 break; 1655 case GLX_MAX_PBUFFER_PIXELS: 1656 if (!fbconfig) 1657 return GLX_BAD_ATTRIBUTE; 1658 *value = DisplayWidth(xmvis->display, xmvis->visinfo->screen) * 1659 DisplayHeight(xmvis->display, xmvis->visinfo->screen); 1660 break; 1661 case GLX_VISUAL_ID: 1662 if (!fbconfig) 1663 return GLX_BAD_ATTRIBUTE; 1664 *value = xmvis->visinfo->visualid; 1665 break; 1666 1667 #ifdef GLX_EXT_texture_from_pixmap 1668 case GLX_BIND_TO_TEXTURE_RGB_EXT: 1669 *value = True; /*XXX*/ 1670 break; 1671 case GLX_BIND_TO_TEXTURE_RGBA_EXT: 1672 /* XXX review */ 1673 *value = xmvis->mesa_visual.alphaBits > 0 ? True : False; 1674 break; 1675 case GLX_BIND_TO_MIPMAP_TEXTURE_EXT: 1676 *value = True; /*XXX*/ 1677 break; 1678 case GLX_BIND_TO_TEXTURE_TARGETS_EXT: 1679 *value = (GLX_TEXTURE_1D_BIT_EXT | 1680 GLX_TEXTURE_2D_BIT_EXT | 1681 GLX_TEXTURE_RECTANGLE_BIT_EXT); /*XXX*/ 1682 break; 1683 case GLX_Y_INVERTED_EXT: 1684 *value = True; /*XXX*/ 1685 break; 1686 #endif 1687 1688 default: 1689 return GLX_BAD_ATTRIBUTE; 1690 } 1691 return Success; 1692 } 1693 1694 1695 PUBLIC int 1696 glXGetConfig( Display *dpy, XVisualInfo *visinfo, 1697 int attrib, int *value ) 1698 { 1699 XMesaVisual xmvis; 1700 int k; 1701 if (!dpy || !visinfo) 1702 return GLX_BAD_ATTRIBUTE; 1703 1704 xmvis = find_glx_visual( dpy, visinfo ); 1705 if (!xmvis) { 1706 /* this visual wasn't obtained with glXChooseVisual */ 1707 xmvis = create_glx_visual( dpy, visinfo ); 1708 if (!xmvis) { 1709 /* this visual can't be used for GL rendering */ 1710 if (attrib==GLX_USE_GL) { 1711 *value = (int) False; 1712 return 0; 1713 } 1714 else { 1715 return GLX_BAD_VISUAL; 1716 } 1717 } 1718 } 1719 1720 k = get_config(xmvis, attrib, value, GL_FALSE); 1721 return k; 1722 } 1723 1724 1725 PUBLIC void 1726 glXWaitGL( void ) 1727 { 1728 XMesaContext xmesa = XMesaGetCurrentContext(); 1729 XMesaFlush( xmesa ); 1730 } 1731 1732 1733 1734 PUBLIC void 1735 glXWaitX( void ) 1736 { 1737 XMesaContext xmesa = XMesaGetCurrentContext(); 1738 XMesaFlush( xmesa ); 1739 } 1740 1741 1742 static const char * 1743 get_extensions( void ) 1744 { 1745 return EXTENSIONS; 1746 } 1747 1748 1749 1750 /* GLX 1.1 and later */ 1751 PUBLIC const char * 1752 glXQueryExtensionsString( Display *dpy, int screen ) 1753 { 1754 (void) dpy; 1755 (void) screen; 1756 return get_extensions(); 1757 } 1758 1759 1760 1761 /* GLX 1.1 and later */ 1762 PUBLIC const char * 1763 glXQueryServerString( Display *dpy, int screen, int name ) 1764 { 1765 static char version[1000]; 1766 sprintf(version, "%d.%d %s", 1767 SERVER_MAJOR_VERSION, SERVER_MINOR_VERSION, xmesa_get_name()); 1768 1769 (void) dpy; 1770 (void) screen; 1771 1772 switch (name) { 1773 case GLX_EXTENSIONS: 1774 return get_extensions(); 1775 case GLX_VENDOR: 1776 return VENDOR; 1777 case GLX_VERSION: 1778 return version; 1779 default: 1780 return NULL; 1781 } 1782 } 1783 1784 1785 1786 /* GLX 1.1 and later */ 1787 PUBLIC const char * 1788 glXGetClientString( Display *dpy, int name ) 1789 { 1790 static char version[1000]; 1791 sprintf(version, "%d.%d %s", CLIENT_MAJOR_VERSION, 1792 CLIENT_MINOR_VERSION, xmesa_get_name()); 1793 1794 (void) dpy; 1795 1796 switch (name) { 1797 case GLX_EXTENSIONS: 1798 return get_extensions(); 1799 case GLX_VENDOR: 1800 return VENDOR; 1801 case GLX_VERSION: 1802 return version; 1803 default: 1804 return NULL; 1805 } 1806 } 1807 1808 1809 1810 /* 1811 * GLX 1.3 and later 1812 */ 1813 1814 1815 PUBLIC int 1816 glXGetFBConfigAttrib(Display *dpy, GLXFBConfig config, 1817 int attribute, int *value) 1818 { 1819 XMesaVisual v = (XMesaVisual) config; 1820 (void) dpy; 1821 (void) config; 1822 1823 if (!dpy || !config || !value) 1824 return -1; 1825 1826 return get_config(v, attribute, value, GL_TRUE); 1827 } 1828 1829 1830 PUBLIC GLXFBConfig * 1831 glXGetFBConfigs( Display *dpy, int screen, int *nelements ) 1832 { 1833 XVisualInfo *visuals, visTemplate; 1834 const long visMask = VisualScreenMask; 1835 int i; 1836 1837 /* Get list of all X visuals */ 1838 visTemplate.screen = screen; 1839 visuals = XGetVisualInfo(dpy, visMask, &visTemplate, nelements); 1840 if (*nelements > 0) { 1841 XMesaVisual *results = malloc(*nelements * sizeof(XMesaVisual)); 1842 if (!results) { 1843 *nelements = 0; 1844 return NULL; 1845 } 1846 for (i = 0; i < *nelements; i++) { 1847 results[i] = create_glx_visual(dpy, visuals + i); 1848 if (!results[i]) { 1849 *nelements = i; 1850 break; 1851 } 1852 } 1853 return (GLXFBConfig *) results; 1854 } 1855 return NULL; 1856 } 1857 1858 1859 PUBLIC GLXFBConfig * 1860 glXChooseFBConfig(Display *dpy, int screen, 1861 const int *attribList, int *nitems) 1862 { 1863 XMesaVisual xmvis; 1864 1865 /* register ourselves as an extension on this display */ 1866 register_with_display(dpy); 1867 1868 if (!attribList || !attribList[0]) { 1869 /* return list of all configs (per GLX_SGIX_fbconfig spec) */ 1870 return glXGetFBConfigs(dpy, screen, nitems); 1871 } 1872 1873 xmvis = choose_visual(dpy, screen, attribList, GL_TRUE); 1874 if (xmvis) { 1875 GLXFBConfig *config = malloc(sizeof(XMesaVisual)); 1876 if (!config) { 1877 *nitems = 0; 1878 return NULL; 1879 } 1880 *nitems = 1; 1881 config[0] = (GLXFBConfig) xmvis; 1882 return (GLXFBConfig *) config; 1883 } 1884 else { 1885 *nitems = 0; 1886 return NULL; 1887 } 1888 } 1889 1890 1891 PUBLIC XVisualInfo * 1892 glXGetVisualFromFBConfig( Display *dpy, GLXFBConfig config ) 1893 { 1894 if (dpy && config) { 1895 XMesaVisual xmvis = (XMesaVisual) config; 1896 #if 0 1897 return xmvis->vishandle; 1898 #else 1899 /* create a new vishandle - the cached one may be stale */ 1900 xmvis->vishandle = malloc(sizeof(XVisualInfo)); 1901 if (xmvis->vishandle) { 1902 memcpy(xmvis->vishandle, xmvis->visinfo, sizeof(XVisualInfo)); 1903 } 1904 return xmvis->vishandle; 1905 #endif 1906 } 1907 else { 1908 return NULL; 1909 } 1910 } 1911 1912 1913 PUBLIC GLXWindow 1914 glXCreateWindow(Display *dpy, GLXFBConfig config, Window win, 1915 const int *attribList) 1916 { 1917 XMesaVisual xmvis = (XMesaVisual) config; 1918 XMesaBuffer xmbuf; 1919 if (!xmvis) 1920 return 0; 1921 1922 xmbuf = XMesaCreateWindowBuffer(xmvis, win); 1923 if (!xmbuf) 1924 return 0; 1925 1926 (void) dpy; 1927 (void) attribList; /* Ignored in GLX 1.3 */ 1928 1929 return win; /* A hack for now */ 1930 } 1931 1932 1933 PUBLIC void 1934 glXDestroyWindow( Display *dpy, GLXWindow window ) 1935 { 1936 XMesaBuffer b = XMesaFindBuffer(dpy, (Drawable) window); 1937 if (b) 1938 XMesaDestroyBuffer(b); 1939 /* don't destroy X window */ 1940 } 1941 1942 1943 /* XXX untested */ 1944 PUBLIC GLXPixmap 1945 glXCreatePixmap(Display *dpy, GLXFBConfig config, Pixmap pixmap, 1946 const int *attribList) 1947 { 1948 XMesaVisual v = (XMesaVisual) config; 1949 XMesaBuffer b; 1950 const int *attr; 1951 int target = 0, format = 0, mipmap = 0; 1952 int value; 1953 1954 if (!dpy || !config || !pixmap) 1955 return 0; 1956 1957 for (attr = attribList; attr && *attr; attr++) { 1958 switch (*attr) { 1959 case GLX_TEXTURE_FORMAT_EXT: 1960 attr++; 1961 switch (*attr) { 1962 case GLX_TEXTURE_FORMAT_NONE_EXT: 1963 case GLX_TEXTURE_FORMAT_RGB_EXT: 1964 case GLX_TEXTURE_FORMAT_RGBA_EXT: 1965 format = *attr; 1966 break; 1967 default: 1968 /* error */ 1969 return 0; 1970 } 1971 break; 1972 case GLX_TEXTURE_TARGET_EXT: 1973 attr++; 1974 switch (*attr) { 1975 case GLX_TEXTURE_1D_EXT: 1976 case GLX_TEXTURE_2D_EXT: 1977 case GLX_TEXTURE_RECTANGLE_EXT: 1978 target = *attr; 1979 break; 1980 default: 1981 /* error */ 1982 return 0; 1983 } 1984 break; 1985 case GLX_MIPMAP_TEXTURE_EXT: 1986 attr++; 1987 if (*attr) 1988 mipmap = 1; 1989 break; 1990 default: 1991 /* error */ 1992 return 0; 1993 } 1994 } 1995 1996 if (format == GLX_TEXTURE_FORMAT_RGB_EXT) { 1997 if (get_config(v, GLX_BIND_TO_TEXTURE_RGB_EXT, 1998 &value, GL_TRUE) != Success 1999 || !value) { 2000 return 0; /* error! */ 2001 } 2002 } 2003 else if (format == GLX_TEXTURE_FORMAT_RGBA_EXT) { 2004 if (get_config(v, GLX_BIND_TO_TEXTURE_RGBA_EXT, 2005 &value, GL_TRUE) != Success 2006 || !value) { 2007 return 0; /* error! */ 2008 } 2009 } 2010 if (mipmap) { 2011 if (get_config(v, GLX_BIND_TO_MIPMAP_TEXTURE_EXT, 2012 &value, GL_TRUE) != Success 2013 || !value) { 2014 return 0; /* error! */ 2015 } 2016 } 2017 if (target == GLX_TEXTURE_1D_EXT) { 2018 if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT, 2019 &value, GL_TRUE) != Success 2020 || (value & GLX_TEXTURE_1D_BIT_EXT) == 0) { 2021 return 0; /* error! */ 2022 } 2023 } 2024 else if (target == GLX_TEXTURE_2D_EXT) { 2025 if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT, 2026 &value, GL_TRUE) != Success 2027 || (value & GLX_TEXTURE_2D_BIT_EXT) == 0) { 2028 return 0; /* error! */ 2029 } 2030 } 2031 if (target == GLX_TEXTURE_RECTANGLE_EXT) { 2032 if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT, 2033 &value, GL_TRUE) != Success 2034 || (value & GLX_TEXTURE_RECTANGLE_BIT_EXT) == 0) { 2035 return 0; /* error! */ 2036 } 2037 } 2038 2039 if (format || target || mipmap) { 2040 /* texture from pixmap */ 2041 b = XMesaCreatePixmapTextureBuffer(v, pixmap, 0, format, target, mipmap); 2042 } 2043 else { 2044 b = XMesaCreatePixmapBuffer( v, pixmap, 0 ); 2045 } 2046 if (!b) { 2047 return 0; 2048 } 2049 2050 return pixmap; 2051 } 2052 2053 2054 PUBLIC void 2055 glXDestroyPixmap( Display *dpy, GLXPixmap pixmap ) 2056 { 2057 XMesaBuffer b = XMesaFindBuffer(dpy, (Drawable)pixmap); 2058 if (b) 2059 XMesaDestroyBuffer(b); 2060 /* don't destroy X pixmap */ 2061 } 2062 2063 2064 PUBLIC GLXPbuffer 2065 glXCreatePbuffer(Display *dpy, GLXFBConfig config, const int *attribList) 2066 { 2067 XMesaVisual xmvis = (XMesaVisual) config; 2068 XMesaBuffer xmbuf; 2069 const int *attrib; 2070 int width = 0, height = 0; 2071 GLboolean useLargest = GL_FALSE, preserveContents = GL_FALSE; 2072 2073 (void) dpy; 2074 2075 for (attrib = attribList; *attrib; attrib++) { 2076 switch (*attrib) { 2077 case GLX_PBUFFER_WIDTH: 2078 attrib++; 2079 width = *attrib; 2080 break; 2081 case GLX_PBUFFER_HEIGHT: 2082 attrib++; 2083 height = *attrib; 2084 break; 2085 case GLX_PRESERVED_CONTENTS: 2086 attrib++; 2087 preserveContents = *attrib; 2088 break; 2089 case GLX_LARGEST_PBUFFER: 2090 attrib++; 2091 useLargest = *attrib; 2092 break; 2093 default: 2094 return 0; 2095 } 2096 } 2097 2098 if (width == 0 || height == 0) 2099 return 0; 2100 2101 if (width > PBUFFER_MAX_SIZE || height > PBUFFER_MAX_SIZE) { 2102 /* If allocation would have failed and GLX_LARGEST_PBUFFER is set, 2103 * allocate the largest possible buffer. 2104 */ 2105 if (useLargest) { 2106 width = PBUFFER_MAX_SIZE; 2107 height = PBUFFER_MAX_SIZE; 2108 } 2109 } 2110 2111 xmbuf = XMesaCreatePBuffer( xmvis, 0, width, height); 2112 /* A GLXPbuffer handle must be an X Drawable because that's what 2113 * glXMakeCurrent takes. 2114 */ 2115 if (xmbuf) { 2116 xmbuf->largestPbuffer = useLargest; 2117 xmbuf->preservedContents = preserveContents; 2118 return (GLXPbuffer) xmbuf->ws.drawable; 2119 } 2120 else { 2121 return 0; 2122 } 2123 } 2124 2125 2126 PUBLIC void 2127 glXDestroyPbuffer( Display *dpy, GLXPbuffer pbuf ) 2128 { 2129 XMesaBuffer b = XMesaFindBuffer(dpy, pbuf); 2130 if (b) { 2131 XMesaDestroyBuffer(b); 2132 } 2133 } 2134 2135 2136 PUBLIC void 2137 glXQueryDrawable(Display *dpy, GLXDrawable draw, int attribute, 2138 unsigned int *value) 2139 { 2140 GLuint width, height; 2141 XMesaBuffer xmbuf = XMesaFindBuffer(dpy, draw); 2142 if (!xmbuf) { 2143 generate_error(dpy, GLXBadDrawable, draw, X_GLXGetDrawableAttributes, False); 2144 return; 2145 } 2146 2147 /* make sure buffer's dimensions are up to date */ 2148 xmesa_get_window_size(dpy, xmbuf, &width, &height); 2149 2150 switch (attribute) { 2151 case GLX_WIDTH: 2152 *value = width; 2153 break; 2154 case GLX_HEIGHT: 2155 *value = height; 2156 break; 2157 case GLX_PRESERVED_CONTENTS: 2158 *value = xmbuf->preservedContents; 2159 break; 2160 case GLX_LARGEST_PBUFFER: 2161 *value = xmbuf->largestPbuffer; 2162 break; 2163 case GLX_FBCONFIG_ID: 2164 *value = xmbuf->xm_visual->visinfo->visualid; 2165 return; 2166 #ifdef GLX_EXT_texture_from_pixmap 2167 case GLX_TEXTURE_FORMAT_EXT: 2168 *value = xmbuf->TextureFormat; 2169 break; 2170 case GLX_TEXTURE_TARGET_EXT: 2171 *value = xmbuf->TextureTarget; 2172 break; 2173 case GLX_MIPMAP_TEXTURE_EXT: 2174 *value = xmbuf->TextureMipmap; 2175 break; 2176 #endif 2177 2178 default: 2179 generate_error(dpy, BadValue, 0, X_GLXCreateContextAttribsARB, true); 2180 return; 2181 } 2182 } 2183 2184 2185 PUBLIC GLXContext 2186 glXCreateNewContext( Display *dpy, GLXFBConfig config, 2187 int renderType, GLXContext shareCtx, Bool direct ) 2188 { 2189 XMesaVisual xmvis = (XMesaVisual) config; 2190 2191 if (!dpy || !config || 2192 (renderType != GLX_RGBA_TYPE && renderType != GLX_COLOR_INDEX_TYPE)) 2193 return 0; 2194 2195 return create_context(dpy, xmvis, 2196 shareCtx ? shareCtx->xmesaContext : NULL, 2197 direct, 2198 1, 0, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 0x0); 2199 } 2200 2201 2202 PUBLIC int 2203 glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value ) 2204 { 2205 GLXContext glxCtx = ctx; 2206 XMesaContext xmctx = glxCtx->xmesaContext; 2207 2208 (void) dpy; 2209 (void) ctx; 2210 2211 switch (attribute) { 2212 case GLX_FBCONFIG_ID: 2213 *value = xmctx->xm_visual->visinfo->visualid; 2214 break; 2215 case GLX_RENDER_TYPE: 2216 if (xmctx->xm_visual->mesa_visual.rgbMode) 2217 *value = GLX_RGBA_TYPE; 2218 else 2219 *value = GLX_COLOR_INDEX_TYPE; 2220 break; 2221 case GLX_SCREEN: 2222 *value = 0; 2223 return Success; 2224 default: 2225 return GLX_BAD_ATTRIBUTE; 2226 } 2227 return 0; 2228 } 2229 2230 2231 PUBLIC void 2232 glXSelectEvent( Display *dpy, GLXDrawable drawable, unsigned long mask ) 2233 { 2234 XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable); 2235 if (xmbuf) 2236 xmbuf->selectedEvents = mask; 2237 } 2238 2239 2240 PUBLIC void 2241 glXGetSelectedEvent(Display *dpy, GLXDrawable drawable, unsigned long *mask) 2242 { 2243 XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable); 2244 if (xmbuf) 2245 *mask = xmbuf->selectedEvents; 2246 else 2247 *mask = 0; 2248 } 2249 2250 2251 2252 /*** GLX_SGI_swap_control ***/ 2253 2254 PUBLIC int 2255 glXSwapIntervalSGI(int interval) 2256 { 2257 (void) interval; 2258 return 0; 2259 } 2260 2261 2262 2263 /*** GLX_SGI_video_sync ***/ 2264 2265 static unsigned int FrameCounter = 0; 2266 2267 PUBLIC int 2268 glXGetVideoSyncSGI(unsigned int *count) 2269 { 2270 /* this is a bogus implementation */ 2271 *count = FrameCounter++; 2272 return 0; 2273 } 2274 2275 PUBLIC int 2276 glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count) 2277 { 2278 if (divisor <= 0 || remainder < 0) 2279 return GLX_BAD_VALUE; 2280 /* this is a bogus implementation */ 2281 FrameCounter++; 2282 while (FrameCounter % divisor != remainder) 2283 FrameCounter++; 2284 *count = FrameCounter; 2285 return 0; 2286 } 2287 2288 2289 2290 /*** GLX_SGI_make_current_read ***/ 2291 2292 PUBLIC Bool 2293 glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, 2294 GLXContext ctx) 2295 { 2296 return glXMakeContextCurrent( dpy, draw, read, ctx ); 2297 } 2298 2299 /* not used 2300 static GLXDrawable 2301 glXGetCurrentReadDrawableSGI(void) 2302 { 2303 return 0; 2304 } 2305 */ 2306 2307 2308 /*** GLX_SGIX_video_source ***/ 2309 #if defined(_VL_H) 2310 2311 PUBLIC GLXVideoSourceSGIX 2312 glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, 2313 VLPath path, int nodeClass, VLNode drainNode) 2314 { 2315 (void) dpy; 2316 (void) screen; 2317 (void) server; 2318 (void) path; 2319 (void) nodeClass; 2320 (void) drainNode; 2321 return 0; 2322 } 2323 2324 PUBLIC void 2325 glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src) 2326 { 2327 (void) dpy; 2328 (void) src; 2329 } 2330 2331 #endif 2332 2333 2334 /*** GLX_EXT_import_context ***/ 2335 2336 PUBLIC void 2337 glXFreeContextEXT(Display *dpy, GLXContext context) 2338 { 2339 (void) dpy; 2340 (void) context; 2341 } 2342 2343 PUBLIC GLXContextID 2344 glXGetContextIDEXT(const GLXContext context) 2345 { 2346 (void) context; 2347 return 0; 2348 } 2349 2350 PUBLIC GLXContext 2351 glXImportContextEXT(Display *dpy, GLXContextID contextID) 2352 { 2353 (void) dpy; 2354 (void) contextID; 2355 return 0; 2356 } 2357 2358 PUBLIC int 2359 glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute, 2360 int *value) 2361 { 2362 (void) dpy; 2363 (void) context; 2364 (void) attribute; 2365 (void) value; 2366 return 0; 2367 } 2368 2369 2370 2371 /*** GLX_SGIX_fbconfig ***/ 2372 2373 PUBLIC int 2374 glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, 2375 int attribute, int *value) 2376 { 2377 return glXGetFBConfigAttrib(dpy, config, attribute, value); 2378 } 2379 2380 PUBLIC GLXFBConfigSGIX * 2381 glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, 2382 int *nelements) 2383 { 2384 return (GLXFBConfig *) glXChooseFBConfig(dpy, screen, 2385 attrib_list, nelements); 2386 } 2387 2388 2389 PUBLIC GLXPixmap 2390 glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, 2391 Pixmap pixmap) 2392 { 2393 XMesaVisual xmvis = (XMesaVisual) config; 2394 XMesaBuffer xmbuf = XMesaCreatePixmapBuffer(xmvis, pixmap, 0); 2395 return xmbuf->ws.drawable; /* need to return an X ID */ 2396 } 2397 2398 2399 PUBLIC GLXContext 2400 glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, 2401 int renderType, GLXContext shareCtx, 2402 Bool direct) 2403 { 2404 XMesaVisual xmvis = (XMesaVisual) config; 2405 2406 if (!dpy || !config || 2407 (renderType != GLX_RGBA_TYPE && renderType != GLX_COLOR_INDEX_TYPE)) 2408 return 0; 2409 2410 return create_context(dpy, xmvis, 2411 shareCtx ? shareCtx->xmesaContext : NULL, 2412 direct, 2413 1, 0, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, 0x0); 2414 } 2415 2416 2417 PUBLIC XVisualInfo * 2418 glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config) 2419 { 2420 return glXGetVisualFromFBConfig(dpy, config); 2421 } 2422 2423 2424 PUBLIC GLXFBConfigSGIX 2425 glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis) 2426 { 2427 XMesaVisual xmvis = find_glx_visual(dpy, vis); 2428 if (!xmvis) { 2429 /* This visual wasn't found with glXChooseVisual() */ 2430 xmvis = create_glx_visual(dpy, vis); 2431 } 2432 2433 return (GLXFBConfigSGIX) xmvis; 2434 } 2435 2436 2437 2438 /*** GLX_SGIX_pbuffer ***/ 2439 2440 PUBLIC GLXPbufferSGIX 2441 glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config, 2442 unsigned int width, unsigned int height, 2443 int *attribList) 2444 { 2445 XMesaVisual xmvis = (XMesaVisual) config; 2446 XMesaBuffer xmbuf; 2447 const int *attrib; 2448 GLboolean useLargest = GL_FALSE, preserveContents = GL_FALSE; 2449 2450 (void) dpy; 2451 2452 for (attrib = attribList; attrib && *attrib; attrib++) { 2453 switch (*attrib) { 2454 case GLX_PRESERVED_CONTENTS_SGIX: 2455 attrib++; 2456 preserveContents = *attrib; /* ignored */ 2457 break; 2458 case GLX_LARGEST_PBUFFER_SGIX: 2459 attrib++; 2460 useLargest = *attrib; /* ignored */ 2461 break; 2462 default: 2463 return 0; 2464 } 2465 } 2466 2467 /* not used at this time */ 2468 (void) useLargest; 2469 (void) preserveContents; 2470 2471 xmbuf = XMesaCreatePBuffer( xmvis, 0, width, height); 2472 /* A GLXPbuffer handle must be an X Drawable because that's what 2473 * glXMakeCurrent takes. 2474 */ 2475 return (GLXPbuffer) xmbuf->ws.drawable; 2476 } 2477 2478 2479 PUBLIC void 2480 glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf) 2481 { 2482 XMesaBuffer xmbuf = XMesaFindBuffer(dpy, pbuf); 2483 if (xmbuf) { 2484 XMesaDestroyBuffer(xmbuf); 2485 } 2486 } 2487 2488 2489 PUBLIC int 2490 glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, 2491 unsigned int *value) 2492 { 2493 const XMesaBuffer xmbuf = XMesaFindBuffer(dpy, pbuf); 2494 2495 if (!xmbuf) { 2496 /* Generate GLXBadPbufferSGIX for bad pbuffer */ 2497 return 0; 2498 } 2499 2500 switch (attribute) { 2501 case GLX_PRESERVED_CONTENTS_SGIX: 2502 *value = True; 2503 break; 2504 case GLX_LARGEST_PBUFFER_SGIX: 2505 *value = xmesa_buffer_width(xmbuf) * xmesa_buffer_height(xmbuf); 2506 break; 2507 case GLX_WIDTH_SGIX: 2508 *value = xmesa_buffer_width(xmbuf); 2509 break; 2510 case GLX_HEIGHT_SGIX: 2511 *value = xmesa_buffer_height(xmbuf); 2512 break; 2513 case GLX_EVENT_MASK_SGIX: 2514 *value = 0; /* XXX might be wrong */ 2515 break; 2516 default: 2517 *value = 0; 2518 } 2519 return 0; 2520 } 2521 2522 2523 PUBLIC void 2524 glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask) 2525 { 2526 XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable); 2527 if (xmbuf) { 2528 /* Note: we'll never generate clobber events */ 2529 xmbuf->selectedEvents = mask; 2530 } 2531 } 2532 2533 2534 PUBLIC void 2535 glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, 2536 unsigned long *mask) 2537 { 2538 XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable); 2539 if (xmbuf) { 2540 *mask = xmbuf->selectedEvents; 2541 } 2542 else { 2543 *mask = 0; 2544 } 2545 } 2546 2547 2548 2549 /*** GLX_SGI_cushion ***/ 2550 2551 PUBLIC void 2552 glXCushionSGI(Display *dpy, Window win, float cushion) 2553 { 2554 (void) dpy; 2555 (void) win; 2556 (void) cushion; 2557 } 2558 2559 2560 2561 /*** GLX_SGIX_video_resize ***/ 2562 2563 PUBLIC int 2564 glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel, 2565 Window window) 2566 { 2567 (void) dpy; 2568 (void) screen; 2569 (void) channel; 2570 (void) window; 2571 return 0; 2572 } 2573 2574 PUBLIC int 2575 glXChannelRectSGIX(Display *dpy, int screen, int channel, 2576 int x, int y, int w, int h) 2577 { 2578 (void) dpy; 2579 (void) screen; 2580 (void) channel; 2581 (void) x; 2582 (void) y; 2583 (void) w; 2584 (void) h; 2585 return 0; 2586 } 2587 2588 PUBLIC int 2589 glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, 2590 int *x, int *y, int *w, int *h) 2591 { 2592 (void) dpy; 2593 (void) screen; 2594 (void) channel; 2595 (void) x; 2596 (void) y; 2597 (void) w; 2598 (void) h; 2599 return 0; 2600 } 2601 2602 PUBLIC int 2603 glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, 2604 int *dx, int *dy, int *dw, int *dh) 2605 { 2606 (void) dpy; 2607 (void) screen; 2608 (void) channel; 2609 (void) dx; 2610 (void) dy; 2611 (void) dw; 2612 (void) dh; 2613 return 0; 2614 } 2615 2616 PUBLIC int 2617 glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype) 2618 { 2619 (void) dpy; 2620 (void) screen; 2621 (void) channel; 2622 (void) synctype; 2623 return 0; 2624 } 2625 2626 2627 2628 /*** GLX_SGIX_dmbuffer **/ 2629 2630 #if defined(_DM_BUFFER_H_) 2631 PUBLIC Bool 2632 glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, 2633 DMparams *params, DMbuffer dmbuffer) 2634 { 2635 (void) dpy; 2636 (void) pbuffer; 2637 (void) params; 2638 (void) dmbuffer; 2639 return False; 2640 } 2641 #endif 2642 2643 2644 /*** GLX_SGIX_swap_group ***/ 2645 2646 PUBLIC void 2647 glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member) 2648 { 2649 (void) dpy; 2650 (void) drawable; 2651 (void) member; 2652 } 2653 2654 2655 2656 /*** GLX_SGIX_swap_barrier ***/ 2657 2658 PUBLIC void 2659 glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier) 2660 { 2661 (void) dpy; 2662 (void) drawable; 2663 (void) barrier; 2664 } 2665 2666 PUBLIC Bool 2667 glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max) 2668 { 2669 (void) dpy; 2670 (void) screen; 2671 (void) max; 2672 return False; 2673 } 2674 2675 2676 2677 /*** GLX_SUN_get_transparent_index ***/ 2678 2679 PUBLIC Status 2680 glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, 2681 long *pTransparent) 2682 { 2683 (void) dpy; 2684 (void) overlay; 2685 (void) underlay; 2686 (void) pTransparent; 2687 return 0; 2688 } 2689 2690 2691 2692 /*** GLX_MESA_release_buffers ***/ 2693 2694 /* 2695 * Release the depth, stencil, accum buffers attached to a GLXDrawable 2696 * (a window or pixmap) prior to destroying the GLXDrawable. 2697 */ 2698 PUBLIC Bool 2699 glXReleaseBuffersMESA( Display *dpy, GLXDrawable d ) 2700 { 2701 XMesaBuffer b = XMesaFindBuffer(dpy, d); 2702 if (b) { 2703 XMesaDestroyBuffer(b); 2704 return True; 2705 } 2706 return False; 2707 } 2708 2709 /*** GLX_EXT_texture_from_pixmap ***/ 2710 2711 PUBLIC void 2712 glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer, 2713 const int *attrib_list) 2714 { 2715 XMesaBuffer b = XMesaFindBuffer(dpy, drawable); 2716 if (b) 2717 XMesaBindTexImage(dpy, b, buffer, attrib_list); 2718 } 2719 2720 PUBLIC void 2721 glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer) 2722 { 2723 XMesaBuffer b = XMesaFindBuffer(dpy, drawable); 2724 if (b) 2725 XMesaReleaseTexImage(dpy, b, buffer); 2726 } 2727 2728 2729 2730 /*** GLX_ARB_create_context ***/ 2731 2732 2733 GLXContext 2734 glXCreateContextAttribsARB(Display *dpy, GLXFBConfig config, 2735 GLXContext shareCtx, Bool direct, 2736 const int *attrib_list) 2737 { 2738 XMesaVisual xmvis = (XMesaVisual) config; 2739 int majorVersion = 1, minorVersion = 0; 2740 int contextFlags = 0x0; 2741 int profileMask = GLX_CONTEXT_CORE_PROFILE_BIT_ARB; 2742 int renderType = GLX_RGBA_TYPE; 2743 unsigned i; 2744 Bool done = False; 2745 const int contextFlagsAll = (GLX_CONTEXT_DEBUG_BIT_ARB | 2746 GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB); 2747 GLXContext ctx; 2748 2749 /* parse attrib_list */ 2750 for (i = 0; !done && attrib_list && attrib_list[i]; i++) { 2751 switch (attrib_list[i]) { 2752 case GLX_CONTEXT_MAJOR_VERSION_ARB: 2753 majorVersion = attrib_list[++i]; 2754 break; 2755 case GLX_CONTEXT_MINOR_VERSION_ARB: 2756 minorVersion = attrib_list[++i]; 2757 break; 2758 case GLX_CONTEXT_FLAGS_ARB: 2759 contextFlags = attrib_list[++i]; 2760 break; 2761 case GLX_CONTEXT_PROFILE_MASK_ARB: 2762 profileMask = attrib_list[++i]; 2763 break; 2764 case GLX_RENDER_TYPE: 2765 renderType = attrib_list[++i]; 2766 break; 2767 case 0: 2768 /* end of list */ 2769 done = True; 2770 break; 2771 default: 2772 /* bad attribute */ 2773 generate_error(dpy, BadValue, 0, X_GLXCreateContextAttribsARB, True); 2774 return NULL; 2775 } 2776 } 2777 2778 /* check contextFlags */ 2779 if (contextFlags & ~contextFlagsAll) { 2780 generate_error(dpy, BadValue, 0, X_GLXCreateContextAttribsARB, True); 2781 return NULL; 2782 } 2783 2784 /* check profileMask */ 2785 if (profileMask != GLX_CONTEXT_CORE_PROFILE_BIT_ARB && 2786 profileMask != GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB && 2787 profileMask != GLX_CONTEXT_ES_PROFILE_BIT_EXT) { 2788 generate_error(dpy, GLXBadProfileARB, 0, X_GLXCreateContextAttribsARB, False); 2789 return NULL; 2790 } 2791 2792 /* check renderType */ 2793 if (renderType != GLX_RGBA_TYPE && 2794 renderType != GLX_COLOR_INDEX_TYPE) { 2795 generate_error(dpy, BadValue, 0, X_GLXCreateContextAttribsARB, True); 2796 return NULL; 2797 } 2798 2799 /* check version */ 2800 if (majorVersion <= 0 || 2801 minorVersion < 0 || 2802 (profileMask != GLX_CONTEXT_ES_PROFILE_BIT_EXT && 2803 ((majorVersion == 1 && minorVersion > 5) || 2804 (majorVersion == 2 && minorVersion > 1) || 2805 (majorVersion == 3 && minorVersion > 3) || 2806 (majorVersion == 4 && minorVersion > 5) || 2807 majorVersion > 4))) { 2808 generate_error(dpy, BadMatch, 0, X_GLXCreateContextAttribsARB, True); 2809 return NULL; 2810 } 2811 if (profileMask == GLX_CONTEXT_ES_PROFILE_BIT_EXT && 2812 ((majorVersion == 1 && minorVersion > 1) || 2813 (majorVersion == 2 && minorVersion > 0) || 2814 (majorVersion == 3 && minorVersion > 1) || 2815 majorVersion > 3)) { 2816 /* GLX_EXT_create_context_es2_profile says nothing to justifying a 2817 * different error code for invalid ES versions, but this is what NVIDIA 2818 * does and piglit expects. 2819 */ 2820 generate_error(dpy, GLXBadProfileARB, 0, X_GLXCreateContextAttribsARB, False); 2821 return NULL; 2822 } 2823 2824 if ((contextFlags & GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB) && 2825 majorVersion < 3) { 2826 generate_error(dpy, BadMatch, 0, X_GLXCreateContextAttribsARB, True); 2827 return NULL; 2828 } 2829 2830 if (renderType == GLX_COLOR_INDEX_TYPE && majorVersion >= 3) { 2831 generate_error(dpy, BadMatch, 0, X_GLXCreateContextAttribsARB, True); 2832 return NULL; 2833 } 2834 2835 ctx = create_context(dpy, xmvis, 2836 shareCtx ? shareCtx->xmesaContext : NULL, 2837 direct, 2838 majorVersion, minorVersion, 2839 profileMask, contextFlags); 2840 if (!ctx) { 2841 generate_error(dpy, GLXBadFBConfig, 0, X_GLXCreateContextAttribsARB, False); 2842 } 2843 2844 return ctx; 2845 } 2846
