src/gallium/winsys/xlib/fakeglx.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.1
   4  *
   5  * Copyright (C) 1999-2007  Brian Paul   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  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25
  26 /*
  27  * This is an emulation of the GLX API which allows Mesa/GLX-based programs
  28  * to run on X servers which do not have the real GLX extension.
  29  *
  30  * Thanks to the contributors:
  31  *
  32  * Initial version:  Philip Brown (phil@bolthole.com)
  33  * Better glXGetConfig() support: Armin Liebchen (liebchen@asylum.cs.utah.edu)
  34  * Further visual-handling refinements: Wolfram Gloger
  35  *    (wmglo@Dent.MED.Uni-Muenchen.DE).
  36  *
  37  * Notes:
  38  *   Don't be fooled, stereo isn't supported yet.
  39  */
  40
  41
  42
  43 #include "glxheader.h"
  44 #include "glxapi.h"
  45 #include "GL/xmesa.h"
  46 #include "context.h"
  47 #include "config.h"
  48 #include "macros.h"
  49 #include "imports.h"
  50 #include "mtypes.h"
  51 #include "version.h"
  52 #include "xfonts.h"
  53 #include "xmesaP.h"
  54 #include "state_tracker/st_context.h"
  55 #include "state_tracker/st_public.h"
  56
  57
  58 #ifdef __VMS
  59 #define _mesa_sprintf sprintf
  60 #endif
  61
  62 /* This indicates the client-side GLX API and GLX encoder version. */
  63 #define CLIENT_MAJOR_VERSION 1
  64 #define CLIENT_MINOR_VERSION 4  /* but don't have 1.3's pbuffers, etc yet */
  65
  66 /* This indicates the server-side GLX decoder version.
  67  * GLX 1.4 indicates OpenGL 1.3 support
  68  */
  69 #define SERVER_MAJOR_VERSION 1
  70 #define SERVER_MINOR_VERSION 4
  71
  72 /* This is appended onto the glXGetClient/ServerString version strings. */
  73 #define MESA_GLX_VERSION "Mesa " MESA_VERSION_STRING
  74
  75 /* Who implemented this GLX? */
  76 #define VENDOR "Brian Paul"
  77
  78 #define EXTENSIONS \
  79    "GLX_MESA_set_3dfx_mode " \
  80    "GLX_MESA_copy_sub_buffer " \
  81    "GLX_MESA_pixmap_colormap " \
  82    "GLX_MESA_release_buffers " \
  83    "GLX_ARB_get_proc_address " \
  84    "GLX_EXT_texture_from_pixmap " \
  85    "GLX_EXT_visual_info " \
  86    "GLX_EXT_visual_rating " \
  87    /*"GLX_SGI_video_sync "*/ \
  88    "GLX_SGIX_fbconfig " \
  89    "GLX_SGIX_pbuffer "
  90
  91 /*
  92  * Our fake GLX context will contain a "real" GLX context and an XMesa context.
  93  *
  94  * Note that a pointer to a __GLXcontext is a pointer to a fake_glx_context,
  95  * and vice versa.
  96  *
  97  * We really just need this structure in order to make the libGL functions
  98  * glXGetCurrentContext(), glXGetCurrentDrawable() and glXGetCurrentDisplay()
  99  * work correctly.
 100  */
 101 struct fake_glx_context {
 102    __GLXcontext glxContext;   /* this MUST be first! */
 103    XMesaContext xmesaContext;
 104 };
 105
 106
 107
 108 /**********************************************************************/
 109 /***                       GLX Visual Code                          ***/
 110 /**********************************************************************/
 111
 112 #define DONT_CARE -1
 113
 114
 115 static XMesaVisual *VisualTable = NULL;
 116 static int NumVisuals = 0;
 117
 118
 119 /*
 120  * This struct and some code fragments borrowed
 121  * from Mark Kilgard's GLUT library.
 122  */
 123 typedef struct _OverlayInfo {
 124   /* Avoid 64-bit portability problems by being careful to use
 125      longs due to the way XGetWindowProperty is specified. Note
 126      that these parameters are passed as CARD32s over X
 127      protocol. */
 128   unsigned long overlay_visual;
 129   long transparent_type;
 130   long value;
 131   long layer;
 132 } OverlayInfo;
 133
 134
 135
 136 /* Macro to handle c_class vs class field name in XVisualInfo struct */
 137 #if defined(__cplusplus) || defined(c_plusplus)
 138 #define CLASS c_class
 139 #else
 140 #define CLASS class
 141 #endif
 142
 143
 144
 145 /*
 146  * Test if the given XVisualInfo is usable for Mesa rendering.
 147  */
 148 static GLboolean
 149 is_usable_visual( XVisualInfo *vinfo )
 150 {
 151    switch (vinfo->CLASS) {
 152       case StaticGray:
 153       case GrayScale:
 154          /* Any StaticGray/GrayScale visual works in RGB or CI mode */
 155          return GL_TRUE;
 156       case StaticColor:
 157       case PseudoColor:
 158          /* Any StaticColor/PseudoColor visual of at least 4 bits */
 159          if (vinfo->depth>=4) {
 160             return GL_TRUE;
 161          }
 162          else {
 163             return GL_FALSE;
 164          }
 165       case TrueColor:
 166       case DirectColor:
 167          /* Any depth of TrueColor or DirectColor works in RGB mode */
 168          return GL_TRUE;
 169       default:
 170          /* This should never happen */
 171          return GL_FALSE;
 172    }
 173 }
 174
 175
 176
 177 /**
 178  * Get an array OverlayInfo records for specified screen.
 179  * \param dpy  the display
 180  * \param screen  screen number
 181  * \param numOverlays  returns numver of OverlayInfo records
 182  * \return  pointer to OverlayInfo array, free with XFree()
 183  */
 184 static OverlayInfo *
 185 GetOverlayInfo(Display *dpy, int screen, int *numOverlays)
 186 {
 187    Atom overlayVisualsAtom;
 188    Atom actualType;
 189    Status status;
 190    unsigned char *ovInfo;
 191    unsigned long sizeData, bytesLeft;
 192    int actualFormat;
 193
 194    /*
 195     * The SERVER_OVERLAY_VISUALS property on the root window contains
 196     * a list of overlay visuals.  Get that list now.
 197     */
 198    overlayVisualsAtom = XInternAtom(dpy,"SERVER_OVERLAY_VISUALS", True);
 199    if (overlayVisualsAtom == None) {
 200       return 0;
 201    }
 202
 203    status = XGetWindowProperty(dpy, RootWindow(dpy, screen),
 204                                overlayVisualsAtom, 0L, (long) 10000, False,
 205                                overlayVisualsAtom, &actualType, &actualFormat,
 206                                &sizeData, &bytesLeft,
 207                                &ovInfo);
 208
 209    if (status != Success || actualType != overlayVisualsAtom ||
 210        actualFormat != 32 || sizeData < 4) {
 211       /* something went wrong */
 212       XFree((void *) ovInfo);
 213       *numOverlays = 0;
 214       return NULL;
 215    }
 216
 217    *numOverlays = sizeData / 4;
 218    return (OverlayInfo *) ovInfo;
 219 }
 220
 221
 222
 223 /**
 224  * Return the level (overlay, normal, underlay) of a given XVisualInfo.
 225  * Input:  dpy - the X display
 226  *         vinfo - the XVisualInfo to test
 227  * Return:  level of the visual:
 228  *             0 = normal planes
 229  *            >0 = overlay planes
 230  *            <0 = underlay planes
 231  */
 232 static int
 233 level_of_visual( Display *dpy, XVisualInfo *vinfo )
 234 {
 235    OverlayInfo *overlay_info;
 236    int numOverlaysPerScreen, i;
 237
 238    overlay_info = GetOverlayInfo(dpy, vinfo->screen, &numOverlaysPerScreen);
 239    if (!overlay_info) {
 240       return 0;
 241    }
 242
 243    /* search the overlay visual list for the visual ID of interest */
 244    for (i = 0; i < numOverlaysPerScreen; i++) {
 245       const OverlayInfo *ov = overlay_info + i;
 246       if (ov->overlay_visual == vinfo->visualid) {
 247          /* found the visual */
 248          if (/*ov->transparent_type==1 &&*/ ov->layer!=0) {
 249             int level = ov->layer;
 250             XFree((void *) overlay_info);
 251             return level;
 252          }
 253          else {
 254             XFree((void *) overlay_info);
 255             return 0;
 256          }
 257       }
 258    }
 259
 260    /* The visual ID was not found in the overlay list. */
 261    XFree((void *) overlay_info);
 262    return 0;
 263 }
 264
 265
 266
 267
 268 /*
 269  * Given an XVisualInfo and RGB, Double, and Depth buffer flags, save the
 270  * configuration in our list of GLX visuals.
 271  */
 272 static XMesaVisual
 273 save_glx_visual( Display *dpy, XVisualInfo *vinfo,
 274                  GLboolean rgbFlag, GLboolean alphaFlag, GLboolean dbFlag,
 275                  GLboolean stereoFlag,
 276                  GLint depth_size, GLint stencil_size,
 277                  GLint accumRedSize, GLint accumGreenSize,
 278                  GLint accumBlueSize, GLint accumAlphaSize,
 279                  GLint level, GLint numAuxBuffers )
 280 {
 281    GLboolean ximageFlag = GL_TRUE;
 282    XMesaVisual xmvis;
 283    GLint i;
 284    GLboolean comparePointers;
 285
 286    if (dbFlag) {
 287       /* Check if the MESA_BACK_BUFFER env var is set */
 288       char *backbuffer = _mesa_getenv("MESA_BACK_BUFFER");
 289       if (backbuffer) {
 290          if (backbuffer[0]=='p' || backbuffer[0]=='P') {
 291             ximageFlag = GL_FALSE;
 292          }
 293          else if (backbuffer[0]=='x' || backbuffer[0]=='X') {
 294             ximageFlag = GL_TRUE;
 295          }
 296          else {
 297             _mesa_warning(NULL, "Mesa: invalid value for MESA_BACK_BUFFER environment variable, using an XImage.");
 298          }
 299       }
 300    }
 301
 302    if (stereoFlag) {
 303       /* stereo not supported */
 304       return NULL;
 305    }
 306
 307    /* Comparing IDs uses less memory but sometimes fails. */
 308    /* XXX revisit this after 3.0 is finished. */
 309    if (_mesa_getenv("MESA_GLX_VISUAL_HACK"))
 310       comparePointers = GL_TRUE;
 311    else
 312       comparePointers = GL_FALSE;
 313
 314    /* Force the visual to have an alpha channel */
 315    if (rgbFlag && _mesa_getenv("MESA_GLX_FORCE_ALPHA"))
 316       alphaFlag = GL_TRUE;
 317
 318    /* First check if a matching visual is already in the list */
 319    for (i=0; i<NumVisuals; i++) {
 320       XMesaVisual v = VisualTable[i];
 321       if (v->display == dpy
 322           && v->mesa_visual.level == level
 323           && v->mesa_visual.numAuxBuffers == numAuxBuffers
 324           && v->ximage_flag == ximageFlag
 325           && v->mesa_visual.rgbMode == rgbFlag
 326           && v->mesa_visual.doubleBufferMode == dbFlag
 327           && v->mesa_visual.stereoMode == stereoFlag
 328           && (v->mesa_visual.alphaBits > 0) == alphaFlag
 329           && (v->mesa_visual.depthBits >= depth_size || depth_size == 0)
 330           && (v->mesa_visual.stencilBits >= stencil_size || stencil_size == 0)
 331           && (v->mesa_visual.accumRedBits >= accumRedSize || accumRedSize == 0)
 332           && (v->mesa_visual.accumGreenBits >= accumGreenSize || accumGreenSize == 0)
 333           && (v->mesa_visual.accumBlueBits >= accumBlueSize || accumBlueSize == 0)
 334           && (v->mesa_visual.accumAlphaBits >= accumAlphaSize || accumAlphaSize == 0)) {
 335          /* now either compare XVisualInfo pointers or visual IDs */
 336          if ((!comparePointers && v->visinfo->visualid == vinfo->visualid)
 337              || (comparePointers && v->vishandle == vinfo)) {
 338             return v;
 339          }
 340       }
 341    }
 342
 343    /* Create a new visual and add it to the list. */
 344
 345    xmvis = XMesaCreateVisual( dpy, vinfo, rgbFlag, alphaFlag, dbFlag,
 346                               stereoFlag, ximageFlag,
 347                               depth_size, stencil_size,
 348                               accumRedSize, accumBlueSize,
 349                               accumBlueSize, accumAlphaSize, 0, level,
 350                               GLX_NONE_EXT );
 351    if (xmvis) {
 352       /* Save a copy of the pointer now so we can find this visual again
 353        * if we need to search for it in find_glx_visual().
 354        */
 355       xmvis->vishandle = vinfo;
 356       /* Allocate more space for additional visual */
 357       VisualTable = (XMesaVisual *) _mesa_realloc( VisualTable,
 358                                    sizeof(XMesaVisual) * NumVisuals,
 359                                    sizeof(XMesaVisual) * (NumVisuals + 1));
 360       /* add xmvis to the list */
 361       VisualTable[NumVisuals] = xmvis;
 362       NumVisuals++;
 363       /* XXX minor hack, because XMesaCreateVisual doesn't support an
 364        * aux buffers parameter.
 365        */
 366       xmvis->mesa_visual.numAuxBuffers = numAuxBuffers;
 367    }
 368    return xmvis;
 369 }
 370
 371
 372 /**
 373  * Return the default number of bits for the Z buffer.
 374  * If defined, use the MESA_GLX_DEPTH_BITS env var value.
 375  * Otherwise, use the DEFAULT_SOFTWARE_DEPTH_BITS constant.
 376  * XXX probably do the same thing for stencil, accum, etc.
 377  */
 378 static GLint
 379 default_depth_bits(void)
 380 {
 381    int zBits;
 382    const char *zEnv = _mesa_getenv("MESA_GLX_DEPTH_BITS");
 383    if (zEnv)
 384       zBits = _mesa_atoi(zEnv);
 385    else
 386       zBits = DEFAULT_SOFTWARE_DEPTH_BITS;
 387    return zBits;
 388 }
 389
 390 static GLint
 391 default_alpha_bits(void)
 392 {
 393    int aBits;
 394    const char *aEnv = _mesa_getenv("MESA_GLX_ALPHA_BITS");
 395    if (aEnv)
 396       aBits = _mesa_atoi(aEnv);
 397    else
 398       aBits = 0;
 399    return aBits;
 400 }
 401
 402 static GLint
 403 default_accum_bits(void)
 404 {
 405    return 16;
 406 }
 407
 408
 409
 410 /*
 411  * Create a GLX visual from a regular XVisualInfo.
 412  * This is called when Fake GLX is given an XVisualInfo which wasn't
 413  * returned by glXChooseVisual.  Since this is the first time we're
 414  * considering this visual we'll take a guess at reasonable values
 415  * for depth buffer size, stencil size, accum size, etc.
 416  * This is the best we can do with a client-side emulation of GLX.
 417  */
 418 static XMesaVisual
 419 create_glx_visual( Display *dpy, XVisualInfo *visinfo )
 420 {
 421    int vislevel;
 422    GLint zBits = 24; /*default_depth_bits();*/
 423    GLint accBits = default_accum_bits();
 424    GLboolean alphaFlag = default_alpha_bits() > 0;
 425
 426    vislevel = level_of_visual( dpy, visinfo );
 427    if (vislevel) {
 428       /* Configure this visual as a CI, single-buffered overlay */
 429       return save_glx_visual( dpy, visinfo,
 430                               GL_FALSE,  /* rgb */
 431                               GL_FALSE,  /* alpha */
 432                               GL_FALSE,  /* double */
 433                               GL_FALSE,  /* stereo */
 434                               0,         /* depth bits */
 435                               0,         /* stencil bits */
 436                               0,0,0,0,   /* accum bits */
 437                               vislevel,  /* level */
 438                               0          /* numAux */
 439                             );
 440    }
 441    else if (is_usable_visual( visinfo )) {
 442       if (_mesa_getenv("MESA_GLX_FORCE_CI")) {
 443          /* Configure this visual as a COLOR INDEX visual. */
 444          return save_glx_visual( dpy, visinfo,
 445                                  GL_FALSE,   /* rgb */
 446                                  GL_FALSE,  /* alpha */
 447                                  GL_TRUE,   /* double */
 448                                  GL_FALSE,  /* stereo */
 449                                  zBits,
 450                                  STENCIL_BITS,
 451                                  0, 0, 0, 0, /* accum bits */
 452                                  0,         /* level */
 453                                  0          /* numAux */
 454                                );
 455       }
 456       else {
 457          /* Configure this visual as RGB, double-buffered, depth-buffered. */
 458          /* This is surely wrong for some people's needs but what else */
 459          /* can be done?  They should use glXChooseVisual(). */
 460          return save_glx_visual( dpy, visinfo,
 461                                  GL_TRUE,   /* rgb */
 462                                  alphaFlag, /* alpha */
 463                                  GL_TRUE,   /* double */
 464                                  GL_FALSE,  /* stereo */
 465                                  zBits,
 466                                  STENCIL_BITS,
 467                                  accBits, /* r */
 468                                  accBits, /* g */
 469                                  accBits, /* b */
 470                                  accBits, /* a */
 471                                  0,         /* level */
 472                                  0          /* numAux */
 473                                );
 474       }
 475    }
 476    else {
 477       _mesa_warning(NULL, "Mesa: error in glXCreateContext: bad visual\n");
 478       return NULL;
 479    }
 480 }
 481
 482
 483
 484 /*
 485  * Find the GLX visual associated with an XVisualInfo.
 486  */
 487 static XMesaVisual
 488 find_glx_visual( Display *dpy, XVisualInfo *vinfo )
 489 {
 490    int i;
 491
 492    /* try to match visual id */
 493    for (i=0;i<NumVisuals;i++) {
 494       if (VisualTable[i]->display==dpy
 495           && VisualTable[i]->visinfo->visualid == vinfo->visualid) {
 496          return VisualTable[i];
 497       }
 498    }
 499
 500    /* if that fails, try to match pointers */
 501    for (i=0;i<NumVisuals;i++) {
 502       if (VisualTable[i]->display==dpy && VisualTable[i]->vishandle==vinfo) {
 503          return VisualTable[i];
 504       }
 505    }
 506
 507    return NULL;
 508 }
 509
 510
 511
 512 /**
 513  * Return the transparent pixel value for a GLX visual.
 514  * Input:  glxvis - the glx_visual
 515  * Return:  a pixel value or -1 if no transparent pixel
 516  */
 517 static int
 518 transparent_pixel( XMesaVisual glxvis )
 519 {
 520    Display *dpy = glxvis->display;
 521    XVisualInfo *vinfo = glxvis->visinfo;
 522    OverlayInfo *overlay_info;
 523    int numOverlaysPerScreen, i;
 524
 525    overlay_info = GetOverlayInfo(dpy, vinfo->screen, &numOverlaysPerScreen);
 526    if (!overlay_info) {
 527       return -1;
 528    }
 529
 530    for (i = 0; i < numOverlaysPerScreen; i++) {
 531       const OverlayInfo *ov = overlay_info + i;
 532       if (ov->overlay_visual == vinfo->visualid) {
 533          /* found it! */
 534          if (ov->transparent_type == 0) {
 535             /* type 0 indicates no transparency */
 536             XFree((void *) overlay_info);
 537             return -1;
 538          }
 539          else {
 540             /* ov->value is the transparent pixel */
 541             XFree((void *) overlay_info);
 542             return ov->value;
 543          }
 544       }
 545    }
 546
 547    /* The visual ID was not found in the overlay list. */
 548    XFree((void *) overlay_info);
 549    return -1;
 550 }
 551
 552
 553
 554 /**
 555  * Try to get an X visual which matches the given arguments.
 556  */
 557 static XVisualInfo *
 558 get_visual( Display *dpy, int scr, unsigned int depth, int xclass )
 559 {
 560    XVisualInfo temp, *vis;
 561    long mask;
 562    int n;
 563    unsigned int default_depth;
 564    int default_class;
 565
 566    mask = VisualScreenMask | VisualDepthMask | VisualClassMask;
 567    temp.screen = scr;
 568    temp.depth = depth;
 569    temp.CLASS = xclass;
 570
 571    default_depth = DefaultDepth(dpy,scr);
 572    default_class = DefaultVisual(dpy,scr)->CLASS;
 573
 574    if (depth==default_depth && xclass==default_class) {
 575       /* try to get root window's visual */
 576       temp.visualid = DefaultVisual(dpy,scr)->visualid;
 577       mask |= VisualIDMask;
 578    }
 579
 580    vis = XGetVisualInfo( dpy, mask, &temp, &n );
 581
 582    /* In case bits/pixel > 24, make sure color channels are still <=8 bits.
 583     * An SGI Infinite Reality system, for example, can have 30bpp pixels:
 584     * 10 bits per color channel.  Mesa's limited to a max of 8 bits/channel.
 585     */
 586    if (vis && depth > 24 && (xclass==TrueColor || xclass==DirectColor)) {
 587       if (_mesa_bitcount((GLuint) vis->red_mask  ) <= 8 &&
 588           _mesa_bitcount((GLuint) vis->green_mask) <= 8 &&
 589           _mesa_bitcount((GLuint) vis->blue_mask ) <= 8) {
 590          return vis;
 591       }
 592       else {
 593          XFree((void *) vis);
 594          return NULL;
 595       }
 596    }
 597
 598    return vis;
 599 }
 600
 601
 602
 603 /*
 604  * Retrieve the value of the given environment variable and find
 605  * the X visual which matches it.
 606  * Input:  dpy - the display
 607  *         screen - the screen number
 608  *         varname - the name of the environment variable
 609  * Return:  an XVisualInfo pointer to NULL if error.
 610  */
 611 static XVisualInfo *
 612 get_env_visual(Display *dpy, int scr, const char *varname)
 613 {
 614    char value[100], type[100];
 615    int depth, xclass = -1;
 616    XVisualInfo *vis;
 617
 618    if (!_mesa_getenv( varname )) {
 619       return NULL;
 620    }
 621
 622    _mesa_strncpy( value, _mesa_getenv(varname), 100 );
 623    value[99] = 0;
 624
 625    sscanf( value, "%s %d", type, &depth );
 626
 627    if (_mesa_strcmp(type,"TrueColor")==0)          xclass = TrueColor;
 628    else if (_mesa_strcmp(type,"DirectColor")==0)   xclass = DirectColor;
 629    else if (_mesa_strcmp(type,"PseudoColor")==0)   xclass = PseudoColor;
 630    else if (_mesa_strcmp(type,"StaticColor")==0)   xclass = StaticColor;
 631    else if (_mesa_strcmp(type,"GrayScale")==0)     xclass = GrayScale;
 632    else if (_mesa_strcmp(type,"StaticGray")==0)    xclass = StaticGray;
 633
 634    if (xclass>-1 && depth>0) {
 635       vis = get_visual( dpy, scr, depth, xclass );
 636       if (vis) {
 637          return vis;
 638       }
 639    }
 640
 641    _mesa_warning(NULL, "GLX unable to find visual class=%s, depth=%d.",
 642                  type, depth);
 643
 644    return NULL;
 645 }
 646
 647
 648
 649 /*
 650  * Select an X visual which satisfies the RGBA/CI flag and minimum depth.
 651  * Input:  dpy, screen - X display and screen number
 652  *         rgba - GL_TRUE = RGBA mode, GL_FALSE = CI mode
 653  *         min_depth - minimum visual depth
 654  *         preferred_class - preferred GLX visual class or DONT_CARE
 655  * Return:  pointer to an XVisualInfo or NULL.
 656  */
 657 static XVisualInfo *
 658 choose_x_visual( Display *dpy, int screen, GLboolean rgba, int min_depth,
 659                  int preferred_class )
 660 {
 661    XVisualInfo *vis;
 662    int xclass, visclass = 0;
 663    int depth;
 664
 665    if (rgba) {
 666       Atom hp_cr_maps = XInternAtom(dpy, "_HP_RGB_SMOOTH_MAP_LIST", True);
 667       /* First see if the MESA_RGB_VISUAL env var is defined */
 668       vis = get_env_visual( dpy, screen, "MESA_RGB_VISUAL" );
 669       if (vis) {
 670          return vis;
 671       }
 672       /* Otherwise, search for a suitable visual */
 673       if (preferred_class==DONT_CARE) {
 674          for (xclass=0;xclass<6;xclass++) {
 675             switch (xclass) {
 676                case 0:  visclass = TrueColor;    break;
 677                case 1:  visclass = DirectColor;  break;
 678                case 2:  visclass = PseudoColor;  break;
 679                case 3:  visclass = StaticColor;  break;
 680                case 4:  visclass = GrayScale;    break;
 681                case 5:  visclass = StaticGray;   break;
 682             }
 683             if (min_depth==0) {
 684                /* start with shallowest */
 685                for (depth=0;depth<=32;depth++) {
 686                   if (visclass==TrueColor && depth==8 && !hp_cr_maps) {
 687                      /* Special case:  try to get 8-bit PseudoColor before */
 688                      /* 8-bit TrueColor */
 689                      vis = get_visual( dpy, screen, 8, PseudoColor );
 690                      if (vis) {
 691                         return vis;
 692                      }
 693                   }
 694                   vis = get_visual( dpy, screen, depth, visclass );
 695                   if (vis) {
 696                      return vis;
 697                   }
 698                }
 699             }
 700             else {
 701                /* start with deepest */
 702                for (depth=32;depth>=min_depth;depth--) {
 703                   if (visclass==TrueColor && depth==8 && !hp_cr_maps) {
 704                      /* Special case:  try to get 8-bit PseudoColor before */
 705                      /* 8-bit TrueColor */
 706                      vis = get_visual( dpy, screen, 8, PseudoColor );
 707                      if (vis) {
 708                         return vis;
 709                      }
 710                   }
 711                   vis = get_visual( dpy, screen, depth, visclass );
 712                   if (vis) {
 713                      return vis;
 714                   }
 715                }
 716             }
 717          }
 718       }
 719       else {
 720          /* search for a specific visual class */
 721          switch (preferred_class) {
 722             case GLX_TRUE_COLOR_EXT:    visclass = TrueColor;    break;
 723             case GLX_DIRECT_COLOR_EXT:  visclass = DirectColor;  break;
 724             case GLX_PSEUDO_COLOR_EXT:  visclass = PseudoColor;  break;
 725             case GLX_STATIC_COLOR_EXT:  visclass = StaticColor;  break;
 726             case GLX_GRAY_SCALE_EXT:    visclass = GrayScale;    break;
 727             case GLX_STATIC_GRAY_EXT:   visclass = StaticGray;   break;
 728             default:   return NULL;
 729          }
 730          if (min_depth==0) {
 731             /* start with shallowest */
 732             for (depth=0;depth<=32;depth++) {
 733                vis = get_visual( dpy, screen, depth, visclass );
 734                if (vis) {
 735                   return vis;
 736                }
 737             }
 738          }
 739          else {
 740             /* start with deepest */
 741             for (depth=32;depth>=min_depth;depth--) {
 742                vis = get_visual( dpy, screen, depth, visclass );
 743                if (vis) {
 744                   return vis;
 745                }
 746             }
 747          }
 748       }
 749    }
 750    else {
 751       /* First see if the MESA_CI_VISUAL env var is defined */
 752       vis = get_env_visual( dpy, screen, "MESA_CI_VISUAL" );
 753       if (vis) {
 754          return vis;
 755       }
 756       /* Otherwise, search for a suitable visual, starting with shallowest */
 757       if (preferred_class==DONT_CARE) {
 758          for (xclass=0;xclass<4;xclass++) {
 759             switch (xclass) {
 760                case 0:  visclass = PseudoColor;  break;
 761                case 1:  visclass = StaticColor;  break;
 762                case 2:  visclass = GrayScale;    break;
 763                case 3:  visclass = StaticGray;   break;
 764             }
 765             /* try 8-bit up through 16-bit */
 766             for (depth=8;depth<=16;depth++) {
 767                vis = get_visual( dpy, screen, depth, visclass );
 768                if (vis) {
 769                   return vis;
 770                }
 771             }
 772             /* try min_depth up to 8-bit */
 773             for (depth=min_depth;depth<8;depth++) {
 774                vis = get_visual( dpy, screen, depth, visclass );
 775                if (vis) {
 776                   return vis;
 777                }
 778             }
 779          }
 780       }
 781       else {
 782          /* search for a specific visual class */
 783          switch (preferred_class) {
 784             case GLX_TRUE_COLOR_EXT:    visclass = TrueColor;    break;
 785             case GLX_DIRECT_COLOR_EXT:  visclass = DirectColor;  break;
 786             case GLX_PSEUDO_COLOR_EXT:  visclass = PseudoColor;  break;
 787             case GLX_STATIC_COLOR_EXT:  visclass = StaticColor;  break;
 788             case GLX_GRAY_SCALE_EXT:    visclass = GrayScale;    break;
 789             case GLX_STATIC_GRAY_EXT:   visclass = StaticGray;   break;
 790             default:   return NULL;
 791          }
 792          /* try 8-bit up through 16-bit */
 793          for (depth=8;depth<=16;depth++) {
 794             vis = get_visual( dpy, screen, depth, visclass );
 795             if (vis) {
 796                return vis;
 797             }
 798          }
 799          /* try min_depth up to 8-bit */
 800          for (depth=min_depth;depth<8;depth++) {
 801             vis = get_visual( dpy, screen, depth, visclass );
 802             if (vis) {
 803                return vis;
 804             }
 805          }
 806       }
 807    }
 808
 809    /* didn't find a visual */
 810    return NULL;
 811 }
 812
 813
 814
 815 /*
 816  * Find the deepest X over/underlay visual of at least min_depth.
 817  * Input:  dpy, screen - X display and screen number
 818  *         level - the over/underlay level
 819  *         trans_type - transparent pixel type: GLX_NONE_EXT,
 820  *                      GLX_TRANSPARENT_RGB_EXT, GLX_TRANSPARENT_INDEX_EXT,
 821  *                      or DONT_CARE
 822  *         trans_value - transparent pixel value or DONT_CARE
 823  *         min_depth - minimum visual depth
 824  *         preferred_class - preferred GLX visual class or DONT_CARE
 825  * Return:  pointer to an XVisualInfo or NULL.
 826  */
 827 static XVisualInfo *
 828 choose_x_overlay_visual( Display *dpy, int scr, GLboolean rgbFlag,
 829                          int level, int trans_type, int trans_value,
 830                          int min_depth, int preferred_class )
 831 {
 832    OverlayInfo *overlay_info;
 833    int numOverlaysPerScreen;
 834    int i;
 835    XVisualInfo *deepvis;
 836    int deepest;
 837
 838    /*DEBUG int tt, tv; */
 839
 840    switch (preferred_class) {
 841       case GLX_TRUE_COLOR_EXT:    preferred_class = TrueColor;    break;
 842       case GLX_DIRECT_COLOR_EXT:  preferred_class = DirectColor;  break;
 843       case GLX_PSEUDO_COLOR_EXT:  preferred_class = PseudoColor;  break;
 844       case GLX_STATIC_COLOR_EXT:  preferred_class = StaticColor;  break;
 845       case GLX_GRAY_SCALE_EXT:    preferred_class = GrayScale;    break;
 846       case GLX_STATIC_GRAY_EXT:   preferred_class = StaticGray;   break;
 847       default:                    preferred_class = DONT_CARE;
 848    }
 849
 850    overlay_info = GetOverlayInfo(dpy, scr, &numOverlaysPerScreen);
 851    if (!overlay_info) {
 852       return NULL;
 853    }
 854
 855    /* Search for the deepest overlay which satisifies all criteria. */
 856    deepest = min_depth;
 857    deepvis = NULL;
 858
 859    for (i = 0; i < numOverlaysPerScreen; i++) {
 860       const OverlayInfo *ov = overlay_info + i;
 861       XVisualInfo *vislist, vistemplate;
 862       int count;
 863
 864       if (ov->layer!=level) {
 865          /* failed overlay level criteria */
 866          continue;
 867       }
 868       if (!(trans_type==DONT_CARE
 869             || (trans_type==GLX_TRANSPARENT_INDEX_EXT
 870                 && ov->transparent_type>0)
 871             || (trans_type==GLX_NONE_EXT && ov->transparent_type==0))) {
 872          /* failed transparent pixel type criteria */
 873          continue;
 874       }
 875       if (trans_value!=DONT_CARE && trans_value!=ov->value) {
 876          /* failed transparent pixel value criteria */
 877          continue;
 878       }
 879
 880       /* get XVisualInfo and check the depth */
 881       vistemplate.visualid = ov->overlay_visual;
 882       vistemplate.screen = scr;
 883       vislist = XGetVisualInfo( dpy, VisualIDMask | VisualScreenMask,
 884                                 &vistemplate, &count );
 885
 886       if (count!=1) {
 887          /* something went wrong */
 888          continue;
 889       }
 890       if (preferred_class!=DONT_CARE && preferred_class!=vislist->CLASS) {
 891          /* wrong visual class */
 892          continue;
 893       }
 894
 895       /* if RGB was requested, make sure we have True/DirectColor */
 896       if (rgbFlag && vislist->CLASS != TrueColor
 897           && vislist->CLASS != DirectColor)
 898          continue;
 899
 900       /* if CI was requested, make sure we have a color indexed visual */
 901       if (!rgbFlag
 902           && (vislist->CLASS == TrueColor || vislist->CLASS == DirectColor))
 903          continue;
 904
 905       if (deepvis==NULL || vislist->depth > deepest) {
 906          /* YES!  found a satisfactory visual */
 907          if (deepvis) {
 908             XFree( deepvis );
 909          }
 910          deepest = vislist->depth;
 911          deepvis = vislist;
 912          /* DEBUG  tt = ov->transparent_type;*/
 913          /* DEBUG  tv = ov->value; */
 914       }
 915    }
 916
 917 /*DEBUG
 918    if (deepvis) {
 919       printf("chose 0x%x:  layer=%d depth=%d trans_type=%d trans_value=%d\n",
 920              deepvis->visualid, level, deepvis->depth, tt, tv );
 921    }
 922 */
 923    return deepvis;
 924 }
 925
 926
 927 /**********************************************************************/
 928 /***             Display-related functions                          ***/
 929 /**********************************************************************/
 930
 931
 932 /**
 933  * Free all XMesaVisuals which are associated with the given display.
 934  */
 935 static void
 936 destroy_visuals_on_display(Display *dpy)
 937 {
 938    int i;
 939    for (i = 0; i < NumVisuals; i++) {
 940       if (VisualTable[i]->display == dpy) {
 941          /* remove this visual */
 942          int j;
 943          free(VisualTable[i]);
 944          for (j = i; j < NumVisuals - 1; j++)
 945             VisualTable[j] = VisualTable[j + 1];
 946          NumVisuals--;
 947       }
 948    }
 949 }
 950
 951
 952 /**
 953  * Called from XCloseDisplay() to let us free our display-related data.
 954  */
 955 static int
 956 close_display_callback(Display *dpy, XExtCodes *codes)
 957 {
 958    destroy_visuals_on_display(dpy);
 959    xmesa_destroy_buffers_on_display(dpy);
 960    return 0;
 961 }
 962
 963
 964 /**
 965  * Look for the named extension on given display and return a pointer
 966  * to the _XExtension data, or NULL if extension not found.
 967  */
 968 static _XExtension *
 969 lookup_extension(Display *dpy, const char *extName)
 970 {
 971    _XExtension *ext;
 972    for (ext = dpy->ext_procs; ext; ext = ext->next) {
 973       if (ext->name && strcmp(ext->name, extName) == 0) {
 974          return ext;
 975       }
 976    }
 977    return NULL;
 978 }
 979
 980
 981 /**
 982  * Whenever we're given a new Display pointer, call this function to
 983  * register our close_display_callback function.
 984  */
 985 static void
 986 register_with_display(Display *dpy)
 987 {
 988    const char *extName = "MesaGLX";
 989    _XExtension *ext;
 990
 991    ext = lookup_extension(dpy, extName);
 992    if (!ext) {
 993       XExtCodes *c = XAddExtension(dpy);
 994       ext = dpy->ext_procs;  /* new extension is at head of list */
 995       assert(c->extension == ext->codes.extension);
 996       ext->name = _mesa_strdup(extName);
 997       ext->close_display = close_display_callback;
 998    }
 999 }
1000
1001
1002 /**********************************************************************/
1003 /***                  Begin Fake GLX API Functions                  ***/
1004 /**********************************************************************/
1005
1006
1007 /**
1008  * Helper used by glXChooseVisual and glXChooseFBConfig.
1009  * The fbConfig parameter must be GL_FALSE for the former and GL_TRUE for
1010  * the later.
1011  * In either case, the attribute list is terminated with the value 'None'.
1012  */
1013 static XMesaVisual
1014 choose_visual( Display *dpy, int screen, const int *list, GLboolean fbConfig )
1015 {
1016    const GLboolean rgbModeDefault = fbConfig;
1017    const int *parselist;
1018    XVisualInfo *vis;
1019    int min_ci = 0;
1020    int min_red=0, min_green=0, min_blue=0;
1021    GLboolean rgb_flag = rgbModeDefault;
1022    GLboolean alpha_flag = GL_FALSE;
1023    GLboolean double_flag = GL_FALSE;
1024    GLboolean stereo_flag = GL_FALSE;
1025    GLint depth_size = 0;
1026    GLint stencil_size = 0;
1027    GLint accumRedSize = 0;
1028    GLint accumGreenSize = 0;
1029    GLint accumBlueSize = 0;
1030    GLint accumAlphaSize = 0;
1031    int level = 0;
1032    int visual_type = DONT_CARE;
1033    int trans_type = DONT_CARE;
1034    int trans_value = DONT_CARE;
1035    GLint caveat = DONT_CARE;
1036    XMesaVisual xmvis = NULL;
1037    int desiredVisualID = -1;
1038    int numAux = 0;
1039
1040    parselist = list;
1041
1042    while (*parselist) {
1043
1044       switch (*parselist) {
1045          case GLX_USE_GL:
1046             if (fbConfig) {
1047                /* invalid token */
1048                return NULL;
1049             }
1050             else {
1051                /* skip */
1052                parselist++;
1053             }
1054             break;
1055          case GLX_BUFFER_SIZE:
1056             parselist++;
1057             min_ci = *parselist++;
1058             break;
1059          case GLX_LEVEL:
1060             parselist++;
1061             level = *parselist++;
1062             break;
1063          case GLX_RGBA:
1064             if (fbConfig) {
1065                /* invalid token */
1066                return NULL;
1067             }
1068             else {
1069                rgb_flag = GL_TRUE;
1070                parselist++;
1071             }
1072             break;
1073          case GLX_DOUBLEBUFFER:
1074             parselist++;
1075             if (fbConfig) {
1076                double_flag = *parselist++;
1077             }
1078             else {
1079                double_flag = GL_TRUE;
1080             }
1081             break;
1082          case GLX_STEREO:
1083             parselist++;
1084             if (fbConfig) {
1085                stereo_flag = *parselist++;
1086             }
1087             else {
1088                stereo_flag = GL_TRUE;
1089             }
1090             break;
1091          case GLX_AUX_BUFFERS:
1092             parselist++;
1093             numAux = *parselist++;
1094             if (numAux > MAX_AUX_BUFFERS)
1095                return NULL;
1096             break;
1097          case GLX_RED_SIZE:
1098             parselist++;
1099             min_red = *parselist++;
1100             break;
1101          case GLX_GREEN_SIZE:
1102             parselist++;
1103             min_green = *parselist++;
1104             break;
1105          case GLX_BLUE_SIZE:
1106             parselist++;
1107             min_blue = *parselist++;
1108             break;
1109          case GLX_ALPHA_SIZE:
1110             parselist++;
1111             {
1112                GLint size = *parselist++;
1113                alpha_flag = size ? GL_TRUE : GL_FALSE;
1114             }
1115             break;
1116          case GLX_DEPTH_SIZE:
1117             parselist++;
1118             depth_size = *parselist++;
1119             break;
1120          case GLX_STENCIL_SIZE:
1121             parselist++;
1122             stencil_size = *parselist++;
1123             break;
1124          case GLX_ACCUM_RED_SIZE:
1125             parselist++;
1126             {
1127                GLint size = *parselist++;
1128                accumRedSize = MAX2( accumRedSize, size );
1129             }
1130             break;
1131          case GLX_ACCUM_GREEN_SIZE:
1132             parselist++;
1133             {
1134                GLint size = *parselist++;
1135                accumGreenSize = MAX2( accumGreenSize, size );
1136             }
1137             break;
1138          case GLX_ACCUM_BLUE_SIZE:
1139             parselist++;
1140             {
1141                GLint size = *parselist++;
1142                accumBlueSize = MAX2( accumBlueSize, size );
1143             }
1144             break;
1145          case GLX_ACCUM_ALPHA_SIZE:
1146             parselist++;
1147             {
1148                GLint size = *parselist++;
1149                accumAlphaSize = MAX2( accumAlphaSize, size );
1150             }
1151             break;
1152
1153          /*
1154           * GLX_EXT_visual_info extension
1155           */
1156          case GLX_X_VISUAL_TYPE_EXT:
1157             parselist++;
1158             visual_type = *parselist++;
1159             break;
1160          case GLX_TRANSPARENT_TYPE_EXT:
1161             parselist++;
1162             trans_type = *parselist++;
1163             break;
1164          case GLX_TRANSPARENT_INDEX_VALUE_EXT:
1165             parselist++;
1166             trans_value = *parselist++;
1167             break;
1168          case GLX_TRANSPARENT_RED_VALUE_EXT:
1169          case GLX_TRANSPARENT_GREEN_VALUE_EXT:
1170          case GLX_TRANSPARENT_BLUE_VALUE_EXT:
1171          case GLX_TRANSPARENT_ALPHA_VALUE_EXT:
1172             /* ignore */
1173             parselist++;
1174             parselist++;
1175             break;
1176
1177          /*
1178           * GLX_EXT_visual_info extension
1179           */
1180          case GLX_VISUAL_CAVEAT_EXT:
1181             parselist++;
1182             caveat = *parselist++; /* ignored for now */
1183             break;
1184
1185          /*
1186           * GLX_ARB_multisample
1187           */
1188          case GLX_SAMPLE_BUFFERS_ARB:
1189             /* ms not supported */
1190             return NULL;
1191          case GLX_SAMPLES_ARB:
1192             /* ms not supported */
1193             return NULL;
1194
1195          /*
1196           * FBConfig attribs.
1197           */
1198          case GLX_RENDER_TYPE:
1199             if (!fbConfig)
1200                return NULL;
1201             parselist++;
1202             if (*parselist == GLX_RGBA_BIT) {
1203                rgb_flag = GL_TRUE;
1204             }
1205             else if (*parselist == GLX_COLOR_INDEX_BIT) {
1206                rgb_flag = GL_FALSE;
1207             }
1208             else if (*parselist == 0) {
1209                rgb_flag = GL_TRUE;
1210             }
1211             parselist++;
1212             break;
1213          case GLX_DRAWABLE_TYPE:
1214             if (!fbConfig)
1215                return NULL;
1216             parselist++;
1217             if (*parselist & ~(GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT)) {
1218                return NULL; /* bad bit */
1219             }
1220             parselist++;
1221             break;
1222          case GLX_FBCONFIG_ID:
1223             if (!fbConfig)
1224                return NULL;
1225             parselist++;
1226             desiredVisualID = *parselist++;
1227             break;
1228          case GLX_X_RENDERABLE:
1229             if (!fbConfig)
1230                return NULL;
1231             parselist += 2;
1232             /* ignore */
1233             break;
1234
1235 #ifdef GLX_EXT_texture_from_pixmap
1236          case GLX_BIND_TO_TEXTURE_RGB_EXT:
1237             parselist++; /*skip*/
1238             break;
1239          case GLX_BIND_TO_TEXTURE_RGBA_EXT:
1240             parselist++; /*skip*/
1241             break;
1242          case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
1243             parselist++; /*skip*/
1244             break;
1245          case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
1246             parselist++;
1247             if (*parselist & ~(GLX_TEXTURE_1D_BIT_EXT |
1248                                GLX_TEXTURE_2D_BIT_EXT |
1249                                GLX_TEXTURE_RECTANGLE_BIT_EXT)) {
1250                /* invalid bit */
1251                return NULL;
1252             }
1253             break;
1254          case GLX_Y_INVERTED_EXT:
1255             parselist++; /*skip*/
1256             break;
1257 #endif
1258
1259          case None:
1260             /* end of list */
1261             break;
1262
1263          default:
1264             /* undefined attribute */
1265             _mesa_warning(NULL, "unexpected attrib 0x%x in choose_visual()",
1266                           *parselist);
1267             return NULL;
1268       }
1269    }
1270
1271    (void) caveat;
1272
1273    /*
1274     * Since we're only simulating the GLX extension this function will never
1275     * find any real GL visuals.  Instead, all we can do is try to find an RGB
1276     * or CI visual of appropriate depth.  Other requested attributes such as
1277     * double buffering, depth buffer, etc. will be associated with the X
1278     * visual and stored in the VisualTable[].
1279     */
1280    if (desiredVisualID != -1) {
1281       /* try to get a specific visual, by visualID */
1282       XVisualInfo temp;
1283       int n;
1284       temp.visualid = desiredVisualID;
1285       temp.screen = screen;
1286       vis = XGetVisualInfo(dpy, VisualIDMask | VisualScreenMask, &temp, &n);
1287       if (vis) {
1288          /* give the visual some useful GLX attributes */
1289          double_flag = GL_TRUE;
1290          if (vis->depth > 8)
1291             rgb_flag = GL_TRUE;
1292          depth_size = 24; /*default_depth_bits();*/
1293          stencil_size = STENCIL_BITS;
1294          /* XXX accum??? */
1295       }
1296    }
1297    else if (level==0) {
1298       /* normal color planes */
1299       if (rgb_flag) {
1300          /* Get an RGB visual */
1301          int min_rgb = min_red + min_green + min_blue;
1302          if (min_rgb>1 && min_rgb<8) {
1303             /* a special case to be sure we can get a monochrome visual */
1304             min_rgb = 1;
1305          }
1306          vis = choose_x_visual( dpy, screen, rgb_flag, min_rgb, visual_type );
1307       }
1308       else {
1309          /* Get a color index visual */
1310          vis = choose_x_visual( dpy, screen, rgb_flag, min_ci, visual_type );
1311          accumRedSize = accumGreenSize = accumBlueSize = accumAlphaSize = 0;
1312       }
1313    }
1314    else {
1315       /* over/underlay planes */
1316       if (rgb_flag) {
1317          /* rgba overlay */
1318          int min_rgb = min_red + min_green + min_blue;
1319          if (min_rgb>1 && min_rgb<8) {
1320             /* a special case to be sure we can get a monochrome visual */
1321             min_rgb = 1;
1322          }
1323          vis = choose_x_overlay_visual( dpy, screen, rgb_flag, level,
1324                               trans_type, trans_value, min_rgb, visual_type );
1325       }
1326       else {
1327          /* color index overlay */
1328          vis = choose_x_overlay_visual( dpy, screen, rgb_flag, level,
1329                               trans_type, trans_value, min_ci, visual_type );
1330       }
1331    }
1332
1333    if (vis) {
1334       /* Note: we're not exactly obeying the glXChooseVisual rules here.
1335        * When GLX_DEPTH_SIZE = 1 is specified we're supposed to choose the
1336        * largest depth buffer size, which is 32bits/value.  Instead, we
1337        * return 16 to maintain performance with earlier versions of Mesa.
1338        */
1339       if (stencil_size > 0)
1340          depth_size = 24;  /* if Z and stencil, always use 24+8 format */
1341       else if (depth_size > 24)
1342          depth_size = 32;
1343       else if (depth_size > 16)
1344          depth_size = 24;
1345       else if (depth_size > 0) {
1346          depth_size = default_depth_bits();
1347       }
1348
1349       if (!alpha_flag) {
1350          alpha_flag = default_alpha_bits() > 0;
1351       }
1352
1353       /* we only support one size of stencil and accum buffers. */
1354       if (stencil_size > 0)
1355          stencil_size = STENCIL_BITS;
1356       if (accumRedSize > 0 || accumGreenSize > 0 || accumBlueSize > 0 ||
1357           accumAlphaSize > 0) {
1358          accumRedSize =
1359          accumGreenSize =
1360          accumBlueSize = default_accum_bits();
1361          accumAlphaSize = alpha_flag ? accumRedSize : 0;
1362       }
1363
1364       xmvis = save_glx_visual( dpy, vis, rgb_flag, alpha_flag, double_flag,
1365                                stereo_flag, depth_size, stencil_size,
1366                                accumRedSize, accumGreenSize,
1367                                accumBlueSize, accumAlphaSize, level, numAux );
1368    }
1369
1370    return xmvis;
1371 }
1372
1373
1374 static XVisualInfo *
1375 Fake_glXChooseVisual( Display *dpy, int screen, int *list )
1376 {
1377    XMesaVisual xmvis;
1378
1379    /* register ourselves as an extension on this display */
1380    register_with_display(dpy);
1381
1382    xmvis = choose_visual(dpy, screen, list, GL_FALSE);
1383    if (xmvis) {
1384 #if 0
1385       return xmvis->vishandle;
1386 #else
1387       /* create a new vishandle - the cached one may be stale */
1388       xmvis->vishandle = (XVisualInfo *) _mesa_malloc(sizeof(XVisualInfo));
1389       if (xmvis->vishandle) {
1390          _mesa_memcpy(xmvis->vishandle, xmvis->visinfo, sizeof(XVisualInfo));
1391       }
1392       return xmvis->vishandle;
1393 #endif
1394    }
1395    else
1396       return NULL;
1397 }
1398
1399
1400 static GLXContext
1401 Fake_glXCreateContext( Display *dpy, XVisualInfo *visinfo,
1402                        GLXContext share_list, Bool direct )
1403 {
1404    XMesaVisual xmvis;
1405    struct fake_glx_context *glxCtx;
1406    struct fake_glx_context *shareCtx = (struct fake_glx_context *) share_list;
1407
1408    if (!dpy || !visinfo)
1409       return 0;
1410
1411    glxCtx = CALLOC_STRUCT(fake_glx_context);
1412    if (!glxCtx)
1413       return 0;
1414
1415    /* deallocate unused windows/buffers */
1416 #if 0
1417    XMesaGarbageCollect();
1418 #endif
1419
1420    xmvis = find_glx_visual( dpy, visinfo );
1421    if (!xmvis) {
1422       /* This visual wasn't found with glXChooseVisual() */
1423       xmvis = create_glx_visual( dpy, visinfo );
1424       if (!xmvis) {
1425          /* unusable visual */
1426          _mesa_free(glxCtx);
1427          return NULL;
1428       }
1429    }
1430
1431    glxCtx->xmesaContext = XMesaCreateContext(xmvis,
1432                                    shareCtx ? shareCtx->xmesaContext : NULL);
1433    if (!glxCtx->xmesaContext) {
1434       _mesa_free(glxCtx);
1435       return NULL;
1436    }
1437
1438    glxCtx->glxContext.isDirect = GL_FALSE;
1439    glxCtx->glxContext.currentDpy = dpy;
1440    glxCtx->glxContext.xid = (XID) glxCtx;  /* self pointer */
1441
1442    assert((void *) glxCtx == (void *) &(glxCtx->glxContext));
1443
1444    return (GLXContext) glxCtx;
1445 }
1446
1447
1448 /* XXX these may have to be removed due to thread-safety issues. */
1449 static GLXContext MakeCurrent_PrevContext = 0;
1450 static GLXDrawable MakeCurrent_PrevDrawable = 0;
1451 static GLXDrawable MakeCurrent_PrevReadable = 0;
1452 static XMesaBuffer MakeCurrent_PrevDrawBuffer = 0;
1453 static XMesaBuffer MakeCurrent_PrevReadBuffer = 0;
1454
1455
1456 /* GLX 1.3 and later */
1457 static Bool
1458 Fake_glXMakeContextCurrent( Display *dpy, GLXDrawable draw,
1459                             GLXDrawable read, GLXContext ctx )
1460 {
1461    struct fake_glx_context *glxCtx = (struct fake_glx_context *) ctx;
1462    static boolean firsttime = 1, no_rast = 0;
1463
1464    if (firsttime) {
1465       no_rast = getenv("SP_NO_RAST") != NULL;
1466       firsttime = 0;
1467    }
1468
1469
1470    if (ctx && draw && read) {
1471       XMesaBuffer drawBuffer, readBuffer;
1472       XMesaContext xmctx = glxCtx->xmesaContext;
1473
1474       /* Find the XMesaBuffer which corresponds to the GLXDrawable 'draw' */
1475       if (ctx == MakeCurrent_PrevContext
1476           && draw == MakeCurrent_PrevDrawable) {
1477          drawBuffer = MakeCurrent_PrevDrawBuffer;
1478       }
1479       else {
1480          drawBuffer = XMesaFindBuffer( dpy, draw );
1481       }
1482       if (!drawBuffer) {
1483          /* drawable must be a new window! */
1484          drawBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, draw );
1485          if (!drawBuffer) {
1486             /* Out of memory, or context/drawable depth mismatch */
1487             return False;
1488          }
1489 #ifdef FX
1490          FXcreateContext( xmctx->xm_visual, draw, xmctx, drawBuffer );
1491 #endif
1492       }
1493
1494       /* Find the XMesaBuffer which corresponds to the GLXDrawable 'read' */
1495       if (ctx == MakeCurrent_PrevContext
1496           && read == MakeCurrent_PrevReadable) {
1497          readBuffer = MakeCurrent_PrevReadBuffer;
1498       }
1499       else {
1500          readBuffer = XMesaFindBuffer( dpy, read );
1501       }
1502       if (!readBuffer) {
1503          /* drawable must be a new window! */
1504          readBuffer = XMesaCreateWindowBuffer( xmctx->xm_visual, read );
1505          if (!readBuffer) {
1506             /* Out of memory, or context/drawable depth mismatch */
1507             return False;
1508          }
1509 #ifdef FX
1510          FXcreateContext( xmctx->xm_visual, read, xmctx, readBuffer );
1511 #endif
1512       }
1513
1514       if (no_rast &&
1515           MakeCurrent_PrevContext == ctx &&
1516           MakeCurrent_PrevDrawable == draw &&
1517           MakeCurrent_PrevReadable == read &&
1518           MakeCurrent_PrevDrawBuffer == drawBuffer &&
1519           MakeCurrent_PrevReadBuffer == readBuffer)
1520          return True;
1521
1522       MakeCurrent_PrevContext = ctx;
1523       MakeCurrent_PrevDrawable = draw;
1524       MakeCurrent_PrevReadable = read;
1525       MakeCurrent_PrevDrawBuffer = drawBuffer;
1526       MakeCurrent_PrevReadBuffer = readBuffer;
1527
1528       /* Now make current! */
1529       if (XMesaMakeCurrent2(xmctx, drawBuffer, readBuffer)) {
1530          ((__GLXcontext *) ctx)->currentDpy = dpy;
1531          ((__GLXcontext *) ctx)->currentDrawable = draw;
1532          ((__GLXcontext *) ctx)->currentReadable = read;
1533          return True;
1534       }
1535       else {
1536          return False;
1537       }
1538    }
1539    else if (!ctx && !draw && !read) {
1540       /* release current context w/out assigning new one. */
1541       XMesaMakeCurrent( NULL, NULL );
1542       MakeCurrent_PrevContext = 0;
1543       MakeCurrent_PrevDrawable = 0;
1544       MakeCurrent_PrevReadable = 0;
1545       MakeCurrent_PrevDrawBuffer = 0;
1546       MakeCurrent_PrevReadBuffer = 0;
1547       return True;
1548    }
1549    else {
1550       /* The args must either all be non-zero or all zero.
1551        * This is an error.
1552        */
1553       return False;
1554    }
1555 }
1556
1557
1558 static Bool
1559 Fake_glXMakeCurrent( Display *dpy, GLXDrawable drawable, GLXContext ctx )
1560 {
1561    return Fake_glXMakeContextCurrent( dpy, drawable, drawable, ctx );
1562 }
1563
1564
1565 static GLXPixmap
1566 Fake_glXCreateGLXPixmap( Display *dpy, XVisualInfo *visinfo, Pixmap pixmap )
1567 {
1568    XMesaVisual v;
1569    XMesaBuffer b;
1570
1571    v = find_glx_visual( dpy, visinfo );
1572    if (!v) {
1573       v = create_glx_visual( dpy, visinfo );
1574       if (!v) {
1575          /* unusable visual */
1576          return 0;
1577       }
1578    }
1579
1580    b = XMesaCreatePixmapBuffer( v, pixmap, 0 );
1581    if (!b) {
1582       return 0;
1583    }
1584    return b->drawable;
1585 }
1586
1587
1588 /*** GLX_MESA_pixmap_colormap ***/
1589
1590 static GLXPixmap
1591 Fake_glXCreateGLXPixmapMESA( Display *dpy, XVisualInfo *visinfo,
1592                              Pixmap pixmap, Colormap cmap )
1593 {
1594    XMesaVisual v;
1595    XMesaBuffer b;
1596
1597    v = find_glx_visual( dpy, visinfo );
1598    if (!v) {
1599       v = create_glx_visual( dpy, visinfo );
1600       if (!v) {
1601          /* unusable visual */
1602          return 0;
1603       }
1604    }
1605
1606    b = XMesaCreatePixmapBuffer( v, pixmap, cmap );
1607    if (!b) {
1608       return 0;
1609    }
1610    return b->drawable;
1611 }
1612
1613
1614 static void
1615 Fake_glXDestroyGLXPixmap( Display *dpy, GLXPixmap pixmap )
1616 {
1617    XMesaBuffer b = XMesaFindBuffer(dpy, pixmap);
1618    if (b) {
1619       XMesaDestroyBuffer(b);
1620    }
1621    else if (_mesa_getenv("MESA_DEBUG")) {
1622       _mesa_warning(NULL, "Mesa: glXDestroyGLXPixmap: invalid pixmap\n");
1623    }
1624 }
1625
1626
1627 static void
1628 Fake_glXCopyContext( Display *dpy, GLXContext src, GLXContext dst,
1629                      unsigned long mask )
1630 {
1631    struct fake_glx_context *fakeSrc = (struct fake_glx_context *) src;
1632    struct fake_glx_context *fakeDst = (struct fake_glx_context *) dst;
1633    XMesaContext xm_src = fakeSrc->xmesaContext;
1634    XMesaContext xm_dst = fakeDst->xmesaContext;
1635    (void) dpy;
1636    if (MakeCurrent_PrevContext == src) {
1637       _mesa_Flush();
1638    }
1639    st_copy_context_state( xm_src->st, xm_dst->st, (GLuint) mask );
1640 }
1641
1642
1643 static Bool
1644 Fake_glXQueryExtension( Display *dpy, int *errorb, int *event )
1645 {
1646    /* Mesa's GLX isn't really an X extension but we try to act like one. */
1647    (void) dpy;
1648    (void) errorb;
1649    (void) event;
1650    return True;
1651 }
1652
1653
1654 extern void _kw_ungrab_all( Display *dpy );
1655 void _kw_ungrab_all( Display *dpy )
1656 {
1657    XUngrabPointer( dpy, CurrentTime );
1658    XUngrabKeyboard( dpy, CurrentTime );
1659 }
1660
1661
1662 static void
1663 Fake_glXDestroyContext( Display *dpy, GLXContext ctx )
1664 {
1665    struct fake_glx_context *glxCtx = (struct fake_glx_context *) ctx;
1666    (void) dpy;
1667    MakeCurrent_PrevContext = 0;
1668    MakeCurrent_PrevDrawable = 0;
1669    MakeCurrent_PrevReadable = 0;
1670    MakeCurrent_PrevDrawBuffer = 0;
1671    MakeCurrent_PrevReadBuffer = 0;
1672    XMesaDestroyContext( glxCtx->xmesaContext );
1673    XMesaGarbageCollect();
1674    _mesa_free(glxCtx);
1675 }
1676
1677
1678 static Bool
1679 Fake_glXIsDirect( Display *dpy, GLXContext ctx )
1680 {
1681    (void) dpy;
1682    (void) ctx;
1683    return False;
1684 }
1685
1686
1687
1688 static void
1689 Fake_glXSwapBuffers( Display *dpy, GLXDrawable drawable )
1690 {
1691    XMesaBuffer buffer = XMesaFindBuffer( dpy, drawable );
1692    static boolean firsttime = 1, no_rast = 0;
1693
1694    if (firsttime) {
1695       no_rast = getenv("SP_NO_RAST") != NULL;
1696       firsttime = 0;
1697    }
1698
1699    if (no_rast)
1700       return;
1701
1702    if (buffer) {
1703       XMesaSwapBuffers(buffer);
1704    }
1705    else if (_mesa_getenv("MESA_DEBUG")) {
1706       _mesa_warning(NULL, "glXSwapBuffers: invalid drawable 0x%x\n",
1707                     (int) drawable);
1708    }
1709 }
1710
1711
1712
1713 /*** GLX_MESA_copy_sub_buffer ***/
1714
1715 static void
1716 Fake_glXCopySubBufferMESA( Display *dpy, GLXDrawable drawable,
1717                            int x, int y, int width, int height )
1718 {
1719    XMesaBuffer buffer = XMesaFindBuffer( dpy, drawable );
1720    if (buffer) {
1721       XMesaCopySubBuffer(buffer, x, y, width, height);
1722    }
1723    else if (_mesa_getenv("MESA_DEBUG")) {
1724       _mesa_warning(NULL, "Mesa: glXCopySubBufferMESA: invalid drawable\n");
1725    }
1726 }
1727
1728
1729 static Bool
1730 Fake_glXQueryVersion( Display *dpy, int *maj, int *min )
1731 {
1732    (void) dpy;
1733    /* Return GLX version, not Mesa version */
1734    assert(CLIENT_MAJOR_VERSION == SERVER_MAJOR_VERSION);
1735    *maj = CLIENT_MAJOR_VERSION;
1736    *min = MIN2( CLIENT_MINOR_VERSION, SERVER_MINOR_VERSION );
1737    return True;
1738 }
1739
1740
1741 /*
1742  * Query the GLX attributes of the given XVisualInfo.
1743  */
1744 static int
1745 get_config( XMesaVisual xmvis, int attrib, int *value, GLboolean fbconfig )
1746 {
1747    ASSERT(xmvis);
1748    switch(attrib) {
1749       case GLX_USE_GL:
1750          if (fbconfig)
1751             return GLX_BAD_ATTRIBUTE;
1752          *value = (int) True;
1753          return 0;
1754       case GLX_BUFFER_SIZE:
1755          *value = xmvis->visinfo->depth;
1756          return 0;
1757       case GLX_LEVEL:
1758          *value = xmvis->mesa_visual.level;
1759          return 0;
1760       case GLX_RGBA:
1761          if (fbconfig)
1762             return GLX_BAD_ATTRIBUTE;
1763          if (xmvis->mesa_visual.rgbMode) {
1764             *value = True;
1765          }
1766          else {
1767             *value = False;
1768          }
1769          return 0;
1770       case GLX_DOUBLEBUFFER:
1771          *value = (int) xmvis->mesa_visual.doubleBufferMode;
1772          return 0;
1773       case GLX_STEREO:
1774          *value = (int) xmvis->mesa_visual.stereoMode;
1775          return 0;
1776       case GLX_AUX_BUFFERS:
1777          *value = xmvis->mesa_visual.numAuxBuffers;
1778          return 0;
1779       case GLX_RED_SIZE:
1780          *value = xmvis->mesa_visual.redBits;
1781          return 0;
1782       case GLX_GREEN_SIZE:
1783          *value = xmvis->mesa_visual.greenBits;
1784          return 0;
1785       case GLX_BLUE_SIZE:
1786          *value = xmvis->mesa_visual.blueBits;
1787          return 0;
1788       case GLX_ALPHA_SIZE:
1789          *value = xmvis->mesa_visual.alphaBits;
1790          return 0;
1791       case GLX_DEPTH_SIZE:
1792          *value = xmvis->mesa_visual.depthBits;
1793          return 0;
1794       case GLX_STENCIL_SIZE:
1795          *value = xmvis->mesa_visual.stencilBits;
1796          return 0;
1797       case GLX_ACCUM_RED_SIZE:
1798          *value = xmvis->mesa_visual.accumRedBits;
1799          return 0;
1800       case GLX_ACCUM_GREEN_SIZE:
1801          *value = xmvis->mesa_visual.accumGreenBits;
1802          return 0;
1803       case GLX_ACCUM_BLUE_SIZE:
1804          *value = xmvis->mesa_visual.accumBlueBits;
1805          return 0;
1806       case GLX_ACCUM_ALPHA_SIZE:
1807          *value = xmvis->mesa_visual.accumAlphaBits;
1808          return 0;
1809
1810       /*
1811        * GLX_EXT_visual_info extension
1812        */
1813       case GLX_X_VISUAL_TYPE_EXT:
1814          switch (xmvis->visinfo->CLASS) {
1815             case StaticGray:   *value = GLX_STATIC_GRAY_EXT;   return 0;
1816             case GrayScale:    *value = GLX_GRAY_SCALE_EXT;    return 0;
1817             case StaticColor:  *value = GLX_STATIC_GRAY_EXT;   return 0;
1818             case PseudoColor:  *value = GLX_PSEUDO_COLOR_EXT;  return 0;
1819             case TrueColor:    *value = GLX_TRUE_COLOR_EXT;    return 0;
1820             case DirectColor:  *value = GLX_DIRECT_COLOR_EXT;  return 0;
1821          }
1822          return 0;
1823       case GLX_TRANSPARENT_TYPE_EXT:
1824          if (xmvis->mesa_visual.level==0) {
1825             /* normal planes */
1826             *value = GLX_NONE_EXT;
1827          }
1828          else if (xmvis->mesa_visual.level>0) {
1829             /* overlay */
1830             if (xmvis->mesa_visual.rgbMode) {
1831                *value = GLX_TRANSPARENT_RGB_EXT;
1832             }
1833             else {
1834                *value = GLX_TRANSPARENT_INDEX_EXT;
1835             }
1836          }
1837          else if (xmvis->mesa_visual.level<0) {
1838             /* underlay */
1839             *value = GLX_NONE_EXT;
1840          }
1841          return 0;
1842       case GLX_TRANSPARENT_INDEX_VALUE_EXT:
1843          {
1844             int pixel = transparent_pixel( xmvis );
1845             if (pixel>=0) {
1846                *value = pixel;
1847             }
1848             /* else undefined */
1849          }
1850          return 0;
1851       case GLX_TRANSPARENT_RED_VALUE_EXT:
1852          /* undefined */
1853          return 0;
1854       case GLX_TRANSPARENT_GREEN_VALUE_EXT:
1855          /* undefined */
1856          return 0;
1857       case GLX_TRANSPARENT_BLUE_VALUE_EXT:
1858          /* undefined */
1859          return 0;
1860       case GLX_TRANSPARENT_ALPHA_VALUE_EXT:
1861          /* undefined */
1862          return 0;
1863
1864       /*
1865        * GLX_EXT_visual_info extension
1866        */
1867       case GLX_VISUAL_CAVEAT_EXT:
1868          /* test for zero, just in case */
1869          if (xmvis->mesa_visual.visualRating > 0)
1870             *value = xmvis->mesa_visual.visualRating;
1871          else
1872             *value = GLX_NONE_EXT;
1873          return 0;
1874
1875       /*
1876        * GLX_ARB_multisample
1877        */
1878       case GLX_SAMPLE_BUFFERS_ARB:
1879          *value = 0;
1880          return 0;
1881       case GLX_SAMPLES_ARB:
1882          *value = 0;
1883          return 0;
1884
1885       /*
1886        * For FBConfigs:
1887        */
1888       case GLX_SCREEN_EXT:
1889          if (!fbconfig)
1890             return GLX_BAD_ATTRIBUTE;
1891          *value = xmvis->visinfo->screen;
1892          break;
1893       case GLX_DRAWABLE_TYPE: /*SGIX too */
1894          if (!fbconfig)
1895             return GLX_BAD_ATTRIBUTE;
1896          *value = GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT;
1897          break;
1898       case GLX_RENDER_TYPE_SGIX:
1899          if (!fbconfig)
1900             return GLX_BAD_ATTRIBUTE;
1901          if (xmvis->mesa_visual.rgbMode)
1902             *value = GLX_RGBA_BIT;
1903          else
1904             *value = GLX_COLOR_INDEX_BIT;
1905          break;
1906       case GLX_X_RENDERABLE_SGIX:
1907          if (!fbconfig)
1908             return GLX_BAD_ATTRIBUTE;
1909          *value = True; /* XXX really? */
1910          break;
1911       case GLX_FBCONFIG_ID_SGIX:
1912          if (!fbconfig)
1913             return GLX_BAD_ATTRIBUTE;
1914          *value = xmvis->visinfo->visualid;
1915          break;
1916       case GLX_MAX_PBUFFER_WIDTH:
1917          if (!fbconfig)
1918             return GLX_BAD_ATTRIBUTE;
1919          /* XXX or MAX_WIDTH? */
1920          *value = DisplayWidth(xmvis->display, xmvis->visinfo->screen);
1921          break;
1922       case GLX_MAX_PBUFFER_HEIGHT:
1923          if (!fbconfig)
1924             return GLX_BAD_ATTRIBUTE;
1925          *value = DisplayHeight(xmvis->display, xmvis->visinfo->screen);
1926          break;
1927       case GLX_MAX_PBUFFER_PIXELS:
1928          if (!fbconfig)
1929             return GLX_BAD_ATTRIBUTE;
1930          *value = DisplayWidth(xmvis->display, xmvis->visinfo->screen) *
1931                   DisplayHeight(xmvis->display, xmvis->visinfo->screen);
1932          break;
1933       case GLX_VISUAL_ID:
1934          if (!fbconfig)
1935             return GLX_BAD_ATTRIBUTE;
1936          *value = xmvis->visinfo->visualid;
1937          break;
1938
1939 #ifdef GLX_EXT_texture_from_pixmap
1940       case GLX_BIND_TO_TEXTURE_RGB_EXT:
1941          *value = True; /*XXX*/
1942          break;
1943       case GLX_BIND_TO_TEXTURE_RGBA_EXT:
1944          /* XXX review */
1945          *value = xmvis->mesa_visual.alphaBits > 0 ? True : False;
1946          break;
1947       case GLX_BIND_TO_MIPMAP_TEXTURE_EXT:
1948          *value = True; /*XXX*/
1949          break;
1950       case GLX_BIND_TO_TEXTURE_TARGETS_EXT:
1951          *value = (GLX_TEXTURE_1D_BIT_EXT |
1952                    GLX_TEXTURE_2D_BIT_EXT |
1953                    GLX_TEXTURE_RECTANGLE_BIT_EXT); /*XXX*/
1954          break;
1955       case GLX_Y_INVERTED_EXT:
1956          *value = True; /*XXX*/
1957          break;
1958 #endif
1959
1960       default:
1961          return GLX_BAD_ATTRIBUTE;
1962    }
1963    return Success;
1964 }
1965
1966
1967 static int
1968 Fake_glXGetConfig( Display *dpy, XVisualInfo *visinfo,
1969                    int attrib, int *value )
1970 {
1971    XMesaVisual xmvis;
1972    int k;
1973    if (!dpy || !visinfo)
1974       return GLX_BAD_ATTRIBUTE;
1975
1976    xmvis = find_glx_visual( dpy, visinfo );
1977    if (!xmvis) {
1978       /* this visual wasn't obtained with glXChooseVisual */
1979       xmvis = create_glx_visual( dpy, visinfo );
1980       if (!xmvis) {
1981          /* this visual can't be used for GL rendering */
1982          if (attrib==GLX_USE_GL) {
1983             *value = (int) False;
1984             return 0;
1985          }
1986          else {
1987             return GLX_BAD_VISUAL;
1988          }
1989       }
1990    }
1991
1992    k = get_config(xmvis, attrib, value, GL_FALSE);
1993    return k;
1994 }
1995
1996
1997 static void
1998 Fake_glXWaitGL( void )
1999 {
2000    XMesaContext xmesa = XMesaGetCurrentContext();
2001    XMesaFlush( xmesa );
2002 }
2003
2004
2005
2006 static void
2007 Fake_glXWaitX( void )
2008 {
2009    XMesaContext xmesa = XMesaGetCurrentContext();
2010    XMesaFlush( xmesa );
2011 }
2012
2013
2014 static const char *
2015 get_extensions( void )
2016 {
2017 #ifdef FX
2018    const char *fx = _mesa_getenv("MESA_GLX_FX");
2019    if (fx && fx[0] != 'd') {
2020       return EXTENSIONS;
2021    }
2022 #endif
2023    return EXTENSIONS + 23; /* skip "GLX_MESA_set_3dfx_mode" */
2024 }
2025
2026
2027
2028 /* GLX 1.1 and later */
2029 static const char *
2030 Fake_glXQueryExtensionsString( Display *dpy, int screen )
2031 {
2032    (void) dpy;
2033    (void) screen;
2034    return get_extensions();
2035 }
2036
2037
2038
2039 /* GLX 1.1 and later */
2040 static const char *
2041 Fake_glXQueryServerString( Display *dpy, int screen, int name )
2042 {
2043    static char version[1000];
2044    _mesa_sprintf(version, "%d.%d %s",
2045                  SERVER_MAJOR_VERSION, SERVER_MINOR_VERSION, MESA_GLX_VERSION);
2046
2047    (void) dpy;
2048    (void) screen;
2049
2050    switch (name) {
2051       case GLX_EXTENSIONS:
2052          return get_extensions();
2053       case GLX_VENDOR:
2054          return VENDOR;
2055       case GLX_VERSION:
2056          return version;
2057       default:
2058          return NULL;
2059    }
2060 }
2061
2062
2063
2064 /* GLX 1.1 and later */
2065 static const char *
2066 Fake_glXGetClientString( Display *dpy, int name )
2067 {
2068    static char version[1000];
2069    _mesa_sprintf(version, "%d.%d %s", CLIENT_MAJOR_VERSION,
2070                  CLIENT_MINOR_VERSION, MESA_GLX_VERSION);
2071
2072    (void) dpy;
2073
2074    switch (name) {
2075       case GLX_EXTENSIONS:
2076          return get_extensions();
2077       case GLX_VENDOR:
2078          return VENDOR;
2079       case GLX_VERSION:
2080          return version;
2081       default:
2082          return NULL;
2083    }
2084 }
2085
2086
2087
2088 /*
2089  * GLX 1.3 and later
2090  */
2091
2092
2093 static int
2094 Fake_glXGetFBConfigAttrib( Display *dpy, GLXFBConfig config,
2095                            int attribute, int *value )
2096 {
2097    XMesaVisual v = (XMesaVisual) config;
2098    (void) dpy;
2099    (void) config;
2100
2101    if (!dpy || !config || !value)
2102       return -1;
2103
2104    return get_config(v, attribute, value, GL_TRUE);
2105 }
2106
2107
2108 static GLXFBConfig *
2109 Fake_glXGetFBConfigs( Display *dpy, int screen, int *nelements )
2110 {
2111    XVisualInfo *visuals, visTemplate;
2112    const long visMask = VisualScreenMask;
2113    int i;
2114
2115    /* Get list of all X visuals */
2116    visTemplate.screen = screen;
2117    visuals = XGetVisualInfo(dpy, visMask, &visTemplate, nelements);
2118    if (*nelements > 0) {
2119       XMesaVisual *results;
2120       results = (XMesaVisual *) _mesa_malloc(*nelements * sizeof(XMesaVisual));
2121       if (!results) {
2122          *nelements = 0;
2123          return NULL;
2124       }
2125       for (i = 0; i < *nelements; i++) {
2126          results[i] = create_glx_visual(dpy, visuals + i);
2127       }
2128       return (GLXFBConfig *) results;
2129    }
2130    return NULL;
2131 }
2132
2133
2134 static GLXFBConfig *
2135 Fake_glXChooseFBConfig( Display *dpy, int screen,
2136                         const int *attribList, int *nitems )
2137 {
2138    XMesaVisual xmvis;
2139
2140    if (!attribList || !attribList[0]) {
2141       /* return list of all configs (per GLX_SGIX_fbconfig spec) */
2142       return Fake_glXGetFBConfigs(dpy, screen, nitems);
2143    }
2144
2145    xmvis = choose_visual(dpy, screen, attribList, GL_TRUE);
2146    if (xmvis) {
2147       GLXFBConfig *config = (GLXFBConfig *) _mesa_malloc(sizeof(XMesaVisual));
2148       if (!config) {
2149          *nitems = 0;
2150          return NULL;
2151       }
2152       *nitems = 1;
2153       config[0] = (GLXFBConfig) xmvis;
2154       return (GLXFBConfig *) config;
2155    }
2156    else {
2157       *nitems = 0;
2158       return NULL;
2159    }
2160 }
2161
2162
2163 static XVisualInfo *
2164 Fake_glXGetVisualFromFBConfig( Display *dpy, GLXFBConfig config )
2165 {
2166    if (dpy && config) {
2167       XMesaVisual xmvis = (XMesaVisual) config;
2168 #if 0
2169       return xmvis->vishandle;
2170 #else
2171       /* create a new vishandle - the cached one may be stale */
2172       xmvis->vishandle = (XVisualInfo *) _mesa_malloc(sizeof(XVisualInfo));
2173       if (xmvis->vishandle) {
2174          _mesa_memcpy(xmvis->vishandle, xmvis->visinfo, sizeof(XVisualInfo));
2175       }
2176       return xmvis->vishandle;
2177 #endif
2178    }
2179    else {
2180       return NULL;
2181    }
2182 }
2183
2184
2185 static GLXWindow
2186 Fake_glXCreateWindow( Display *dpy, GLXFBConfig config, Window win,
2187                       const int *attribList )
2188 {
2189    XMesaVisual xmvis = (XMesaVisual) config;
2190    XMesaBuffer xmbuf;
2191    if (!xmvis)
2192       return 0;
2193
2194    xmbuf = XMesaCreateWindowBuffer(xmvis, win);
2195    if (!xmbuf)
2196       return 0;
2197
2198 #ifdef FX
2199    /* XXX this will segfault if actually called */
2200    FXcreateContext(xmvis, win, NULL, xmbuf);
2201 #endif
2202
2203    (void) dpy;
2204    (void) attribList;  /* Ignored in GLX 1.3 */
2205
2206    return win;  /* A hack for now */
2207 }
2208
2209
2210 static void
2211 Fake_glXDestroyWindow( Display *dpy, GLXWindow window )
2212 {
2213    XMesaBuffer b = XMesaFindBuffer(dpy, (XMesaDrawable) window);
2214    if (b)
2215       XMesaDestroyBuffer(b);
2216    /* don't destroy X window */
2217 }
2218
2219
2220 /* XXX untested */
2221 static GLXPixmap
2222 Fake_glXCreatePixmap( Display *dpy, GLXFBConfig config, Pixmap pixmap,
2223                       const int *attribList )
2224 {
2225    XMesaVisual v = (XMesaVisual) config;
2226    XMesaBuffer b;
2227    const int *attr;
2228    int target = 0, format = 0, mipmap = 0;
2229    int value;
2230
2231    if (!dpy || !config || !pixmap)
2232       return 0;
2233
2234    for (attr = attribList; *attr; attr++) {
2235       switch (*attr) {
2236       case GLX_TEXTURE_FORMAT_EXT:
2237          attr++;
2238          switch (*attr) {
2239          case GLX_TEXTURE_FORMAT_NONE_EXT:
2240          case GLX_TEXTURE_FORMAT_RGB_EXT:
2241          case GLX_TEXTURE_FORMAT_RGBA_EXT:
2242             format = *attr;
2243             break;
2244          default:
2245             /* error */
2246             return 0;
2247          }
2248          break;
2249       case GLX_TEXTURE_TARGET_EXT:
2250          attr++;
2251          switch (*attr) {
2252          case GLX_TEXTURE_1D_EXT:
2253          case GLX_TEXTURE_2D_EXT:
2254          case GLX_TEXTURE_RECTANGLE_EXT:
2255             target = *attr;
2256             break;
2257          default:
2258             /* error */
2259             return 0;
2260          }
2261          break;
2262       case GLX_MIPMAP_TEXTURE_EXT:
2263          attr++;
2264          if (*attr)
2265             mipmap = 1;
2266          break;
2267       default:
2268          /* error */
2269          return 0;
2270       }
2271    }
2272
2273    if (format == GLX_TEXTURE_FORMAT_RGB_EXT) {
2274       if (get_config(v, GLX_BIND_TO_TEXTURE_RGB_EXT,
2275                      &value, GL_TRUE) != Success
2276           || !value) {
2277          return 0; /* error! */
2278       }
2279    }
2280    else if (format == GLX_TEXTURE_FORMAT_RGBA_EXT) {
2281       if (get_config(v, GLX_BIND_TO_TEXTURE_RGBA_EXT,
2282                      &value, GL_TRUE) != Success
2283           || !value) {
2284          return 0; /* error! */
2285       }
2286    }
2287    if (mipmap) {
2288       if (get_config(v, GLX_BIND_TO_MIPMAP_TEXTURE_EXT,
2289                      &value, GL_TRUE) != Success
2290           || !value) {
2291          return 0; /* error! */
2292       }
2293    }
2294    if (target == GLX_TEXTURE_1D_EXT) {
2295       if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
2296                      &value, GL_TRUE) != Success
2297           || (value & GLX_TEXTURE_1D_BIT_EXT) == 0) {
2298          return 0; /* error! */
2299       }
2300    }
2301    else if (target == GLX_TEXTURE_2D_EXT) {
2302       if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
2303                      &value, GL_TRUE) != Success
2304           || (value & GLX_TEXTURE_2D_BIT_EXT) == 0) {
2305          return 0; /* error! */
2306       }
2307    }
2308    if (target == GLX_TEXTURE_RECTANGLE_EXT) {
2309       if (get_config(v, GLX_BIND_TO_TEXTURE_TARGETS_EXT,
2310                      &value, GL_TRUE) != Success
2311           || (value & GLX_TEXTURE_RECTANGLE_BIT_EXT) == 0) {
2312          return 0; /* error! */
2313       }
2314    }
2315
2316    if (format || target || mipmap) {
2317       /* texture from pixmap */
2318       b = XMesaCreatePixmapTextureBuffer(v, pixmap, 0, format, target, mipmap);
2319    }
2320    else {
2321       b = XMesaCreatePixmapBuffer( v, pixmap, 0 );
2322    }
2323    if (!b) {
2324       return 0;
2325    }
2326
2327    return pixmap;
2328 }
2329
2330
2331 static void
2332 Fake_glXDestroyPixmap( Display *dpy, GLXPixmap pixmap )
2333 {
2334    XMesaBuffer b = XMesaFindBuffer(dpy, (XMesaDrawable)pixmap);
2335    if (b)
2336       XMesaDestroyBuffer(b);
2337    /* don't destroy X pixmap */
2338 }
2339
2340
2341 static GLXPbuffer
2342 Fake_glXCreatePbuffer( Display *dpy, GLXFBConfig config,
2343                        const int *attribList )
2344 {
2345    XMesaVisual xmvis = (XMesaVisual) config;
2346    XMesaBuffer xmbuf;
2347    const int *attrib;
2348    int width = 0, height = 0;
2349    GLboolean useLargest = GL_FALSE, preserveContents = GL_FALSE;
2350
2351    (void) dpy;
2352
2353    for (attrib = attribList; *attrib; attrib++) {
2354       switch (*attrib) {
2355          case GLX_PBUFFER_WIDTH:
2356             attrib++;
2357             width = *attrib;
2358             break;
2359          case GLX_PBUFFER_HEIGHT:
2360             attrib++;
2361             height = *attrib;
2362             break;
2363          case GLX_PRESERVED_CONTENTS:
2364             attrib++;
2365             preserveContents = *attrib; /* ignored */
2366             break;
2367          case GLX_LARGEST_PBUFFER:
2368             attrib++;
2369             useLargest = *attrib; /* ignored */
2370             break;
2371          default:
2372             return 0;
2373       }
2374    }
2375
2376    /* not used at this time */
2377    (void) useLargest;
2378    (void) preserveContents;
2379
2380    if (width == 0 || height == 0)
2381       return 0;
2382
2383    xmbuf = XMesaCreatePBuffer( xmvis, 0, width, height);
2384    /* A GLXPbuffer handle must be an X Drawable because that's what
2385     * glXMakeCurrent takes.
2386     */
2387    if (xmbuf)
2388       return (GLXPbuffer) xmbuf->drawable;
2389    else
2390       return 0;
2391 }
2392
2393
2394 static void
2395 Fake_glXDestroyPbuffer( Display *dpy, GLXPbuffer pbuf )
2396 {
2397    XMesaBuffer b = XMesaFindBuffer(dpy, pbuf);
2398    if (b) {
2399       XMesaDestroyBuffer(b);
2400    }
2401 }
2402
2403
2404 static void
2405 Fake_glXQueryDrawable( Display *dpy, GLXDrawable draw, int attribute,
2406                        unsigned int *value )
2407 {
2408    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, draw);
2409    if (!xmbuf)
2410       return;
2411
2412    switch (attribute) {
2413       case GLX_WIDTH:
2414          *value = xmesa_buffer_width(xmbuf);
2415          break;
2416       case GLX_HEIGHT:
2417          *value = xmesa_buffer_width(xmbuf);
2418          break;
2419       case GLX_PRESERVED_CONTENTS:
2420          *value = True;
2421          break;
2422       case GLX_LARGEST_PBUFFER:
2423          *value = xmesa_buffer_width(xmbuf) * xmesa_buffer_height(xmbuf);
2424          break;
2425       case GLX_FBCONFIG_ID:
2426          *value = xmbuf->xm_visual->visinfo->visualid;
2427          return;
2428 #ifdef GLX_EXT_texture_from_pixmap
2429       case GLX_TEXTURE_FORMAT_EXT:
2430          *value = xmbuf->TextureFormat;
2431          break;
2432       case GLX_TEXTURE_TARGET_EXT:
2433          *value = xmbuf->TextureTarget;
2434          break;
2435       case GLX_MIPMAP_TEXTURE_EXT:
2436          *value = xmbuf->TextureMipmap;
2437          break;
2438 #endif
2439
2440       default:
2441          return; /* raise BadValue error */
2442    }
2443 }
2444
2445
2446 static GLXContext
2447 Fake_glXCreateNewContext( Display *dpy, GLXFBConfig config,
2448                           int renderType, GLXContext shareList, Bool direct )
2449 {
2450    struct fake_glx_context *glxCtx;
2451    struct fake_glx_context *shareCtx = (struct fake_glx_context *) shareList;
2452    XMesaVisual xmvis = (XMesaVisual) config;
2453
2454    if (!dpy || !config ||
2455        (renderType != GLX_RGBA_TYPE && renderType != GLX_COLOR_INDEX_TYPE))
2456       return 0;
2457
2458    glxCtx = CALLOC_STRUCT(fake_glx_context);
2459    if (!glxCtx)
2460       return 0;
2461
2462    /* deallocate unused windows/buffers */
2463    XMesaGarbageCollect();
2464
2465    glxCtx->xmesaContext = XMesaCreateContext(xmvis,
2466                                    shareCtx ? shareCtx->xmesaContext : NULL);
2467    if (!glxCtx->xmesaContext) {
2468       _mesa_free(glxCtx);
2469       return NULL;
2470    }
2471
2472    glxCtx->glxContext.isDirect = GL_FALSE;
2473    glxCtx->glxContext.currentDpy = dpy;
2474    glxCtx->glxContext.xid = (XID) glxCtx;  /* self pointer */
2475
2476    assert((void *) glxCtx == (void *) &(glxCtx->glxContext));
2477
2478    return (GLXContext) glxCtx;
2479 }
2480
2481
2482 static int
2483 Fake_glXQueryContext( Display *dpy, GLXContext ctx, int attribute, int *value )
2484 {
2485    struct fake_glx_context *glxCtx = (struct fake_glx_context *) ctx;
2486    XMesaContext xmctx = glxCtx->xmesaContext;
2487
2488    (void) dpy;
2489    (void) ctx;
2490
2491    switch (attribute) {
2492    case GLX_FBCONFIG_ID:
2493       *value = xmctx->xm_visual->visinfo->visualid;
2494       break;
2495    case GLX_RENDER_TYPE:
2496       if (xmctx->xm_visual->mesa_visual.rgbMode)
2497          *value = GLX_RGBA_BIT;
2498       else
2499          *value = GLX_COLOR_INDEX_BIT;
2500       break;
2501    case GLX_SCREEN:
2502       *value = 0;
2503       return Success;
2504    default:
2505       return GLX_BAD_ATTRIBUTE;
2506    }
2507    return 0;
2508 }
2509
2510
2511 static void
2512 Fake_glXSelectEvent( Display *dpy, GLXDrawable drawable, unsigned long mask )
2513 {
2514    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable);
2515    if (xmbuf)
2516       xmbuf->selectedEvents = mask;
2517 }
2518
2519
2520 static void
2521 Fake_glXGetSelectedEvent( Display *dpy, GLXDrawable drawable,
2522                           unsigned long *mask )
2523 {
2524    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable);
2525    if (xmbuf)
2526       *mask = xmbuf->selectedEvents;
2527    else
2528       *mask = 0;
2529 }
2530
2531
2532
2533 /*** GLX_SGI_swap_control ***/
2534
2535 static int
2536 Fake_glXSwapIntervalSGI(int interval)
2537 {
2538    (void) interval;
2539    return 0;
2540 }
2541
2542
2543
2544 /*** GLX_SGI_video_sync ***/
2545
2546 static unsigned int FrameCounter = 0;
2547
2548 static int
2549 Fake_glXGetVideoSyncSGI(unsigned int *count)
2550 {
2551    /* this is a bogus implementation */
2552    *count = FrameCounter++;
2553    return 0;
2554 }
2555
2556 static int
2557 Fake_glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
2558 {
2559    if (divisor <= 0 || remainder < 0)
2560       return GLX_BAD_VALUE;
2561    /* this is a bogus implementation */
2562    FrameCounter++;
2563    while (FrameCounter % divisor != remainder)
2564       FrameCounter++;
2565    *count = FrameCounter;
2566    return 0;
2567 }
2568
2569
2570
2571 /*** GLX_SGI_make_current_read ***/
2572
2573 static Bool
2574 Fake_glXMakeCurrentReadSGI(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx)
2575 {
2576    return Fake_glXMakeContextCurrent( dpy, draw, read, ctx );
2577 }
2578
2579 /* not used
2580 static GLXDrawable
2581 Fake_glXGetCurrentReadDrawableSGI(void)
2582 {
2583    return 0;
2584 }
2585 */
2586
2587
2588 /*** GLX_SGIX_video_source ***/
2589 #if defined(_VL_H)
2590
2591 static GLXVideoSourceSGIX
2592 Fake_glXCreateGLXVideoSourceSGIX(Display *dpy, int screen, VLServer server, VLPath path, int nodeClass, VLNode drainNode)
2593 {
2594    (void) dpy;
2595    (void) screen;
2596    (void) server;
2597    (void) path;
2598    (void) nodeClass;
2599    (void) drainNode;
2600    return 0;
2601 }
2602
2603 static void
2604 Fake_glXDestroyGLXVideoSourceSGIX(Display *dpy, GLXVideoSourceSGIX src)
2605 {
2606    (void) dpy;
2607    (void) src;
2608 }
2609
2610 #endif
2611
2612
2613 /*** GLX_EXT_import_context ***/
2614
2615 static void
2616 Fake_glXFreeContextEXT(Display *dpy, GLXContext context)
2617 {
2618    (void) dpy;
2619    (void) context;
2620 }
2621
2622 static GLXContextID
2623 Fake_glXGetContextIDEXT(const GLXContext context)
2624 {
2625    (void) context;
2626    return 0;
2627 }
2628
2629 static GLXContext
2630 Fake_glXImportContextEXT(Display *dpy, GLXContextID contextID)
2631 {
2632    (void) dpy;
2633    (void) contextID;
2634    return 0;
2635 }
2636
2637 static int
2638 Fake_glXQueryContextInfoEXT(Display *dpy, GLXContext context, int attribute, int *value)
2639 {
2640    (void) dpy;
2641    (void) context;
2642    (void) attribute;
2643    (void) value;
2644    return 0;
2645 }
2646
2647
2648
2649 /*** GLX_SGIX_fbconfig ***/
2650
2651 static int
2652 Fake_glXGetFBConfigAttribSGIX(Display *dpy, GLXFBConfigSGIX config, int attribute, int *value)
2653 {
2654    return Fake_glXGetFBConfigAttrib(dpy, config, attribute, value);
2655 }
2656
2657 static GLXFBConfigSGIX *
2658 Fake_glXChooseFBConfigSGIX(Display *dpy, int screen, int *attrib_list, int *nelements)
2659 {
2660    return (GLXFBConfig *) Fake_glXChooseFBConfig(dpy, screen, attrib_list, nelements);
2661 }
2662
2663
2664 static GLXPixmap
2665 Fake_glXCreateGLXPixmapWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, Pixmap pixmap)
2666 {
2667    XMesaVisual xmvis = (XMesaVisual) config;
2668    XMesaBuffer xmbuf = XMesaCreatePixmapBuffer(xmvis, pixmap, 0);
2669    return xmbuf->drawable; /* need to return an X ID */
2670 }
2671
2672
2673 static GLXContext
2674 Fake_glXCreateContextWithConfigSGIX(Display *dpy, GLXFBConfigSGIX config, int render_type, GLXContext share_list, Bool direct)
2675 {
2676    XMesaVisual xmvis = (XMesaVisual) config;
2677    struct fake_glx_context *glxCtx;
2678    struct fake_glx_context *shareCtx = (struct fake_glx_context *) share_list;
2679
2680    glxCtx = CALLOC_STRUCT(fake_glx_context);
2681    if (!glxCtx)
2682       return 0;
2683
2684    /* deallocate unused windows/buffers */
2685    XMesaGarbageCollect();
2686
2687    glxCtx->xmesaContext = XMesaCreateContext(xmvis,
2688                                    shareCtx ? shareCtx->xmesaContext : NULL);
2689    if (!glxCtx->xmesaContext) {
2690       _mesa_free(glxCtx);
2691       return NULL;
2692    }
2693
2694    glxCtx->glxContext.isDirect = GL_FALSE;
2695    glxCtx->glxContext.currentDpy = dpy;
2696    glxCtx->glxContext.xid = (XID) glxCtx;  /* self pointer */
2697
2698    assert((void *) glxCtx == (void *) &(glxCtx->glxContext));
2699
2700    return (GLXContext) glxCtx;
2701 }
2702
2703
2704 static XVisualInfo *
2705 Fake_glXGetVisualFromFBConfigSGIX(Display *dpy, GLXFBConfigSGIX config)
2706 {
2707    return Fake_glXGetVisualFromFBConfig(dpy, config);
2708 }
2709
2710
2711 static GLXFBConfigSGIX
2712 Fake_glXGetFBConfigFromVisualSGIX(Display *dpy, XVisualInfo *vis)
2713 {
2714    XMesaVisual xmvis = find_glx_visual(dpy, vis);
2715    if (!xmvis) {
2716       /* This visual wasn't found with glXChooseVisual() */
2717       xmvis = create_glx_visual(dpy, vis);
2718    }
2719
2720    return (GLXFBConfigSGIX) xmvis;
2721 }
2722
2723
2724
2725 /*** GLX_SGIX_pbuffer ***/
2726
2727 static GLXPbufferSGIX
2728 Fake_glXCreateGLXPbufferSGIX(Display *dpy, GLXFBConfigSGIX config,
2729                              unsigned int width, unsigned int height,
2730                              int *attribList)
2731 {
2732    XMesaVisual xmvis = (XMesaVisual) config;
2733    XMesaBuffer xmbuf;
2734    const int *attrib;
2735    GLboolean useLargest = GL_FALSE, preserveContents = GL_FALSE;
2736
2737    (void) dpy;
2738
2739    for (attrib = attribList; attrib && *attrib; attrib++) {
2740       switch (*attrib) {
2741          case GLX_PRESERVED_CONTENTS_SGIX:
2742             attrib++;
2743             preserveContents = *attrib; /* ignored */
2744             break;
2745          case GLX_LARGEST_PBUFFER_SGIX:
2746             attrib++;
2747             useLargest = *attrib; /* ignored */
2748             break;
2749          default:
2750             return 0;
2751       }
2752    }
2753
2754    /* not used at this time */
2755    (void) useLargest;
2756    (void) preserveContents;
2757
2758    xmbuf = XMesaCreatePBuffer( xmvis, 0, width, height);
2759    /* A GLXPbuffer handle must be an X Drawable because that's what
2760     * glXMakeCurrent takes.
2761     */
2762    return (GLXPbuffer) xmbuf->drawable;
2763 }
2764
2765
2766 static void
2767 Fake_glXDestroyGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf)
2768 {
2769    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, pbuf);
2770    if (xmbuf) {
2771       XMesaDestroyBuffer(xmbuf);
2772    }
2773 }
2774
2775
2776 static int
2777 Fake_glXQueryGLXPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuf, int attribute, unsigned int *value)
2778 {
2779    const XMesaBuffer xmbuf = XMesaFindBuffer(dpy, pbuf);
2780
2781    if (!xmbuf) {
2782       /* Generate GLXBadPbufferSGIX for bad pbuffer */
2783       return 0;
2784    }
2785
2786    switch (attribute) {
2787       case GLX_PRESERVED_CONTENTS_SGIX:
2788          *value = True;
2789          break;
2790       case GLX_LARGEST_PBUFFER_SGIX:
2791          *value = xmesa_buffer_width(xmbuf) * xmesa_buffer_height(xmbuf);
2792          break;
2793       case GLX_WIDTH_SGIX:
2794          *value = xmesa_buffer_width(xmbuf);
2795          break;
2796       case GLX_HEIGHT_SGIX:
2797          *value = xmesa_buffer_height(xmbuf);
2798          break;
2799       case GLX_EVENT_MASK_SGIX:
2800          *value = 0;  /* XXX might be wrong */
2801          break;
2802       default:
2803          *value = 0;
2804    }
2805    return 0;
2806 }
2807
2808
2809 static void
2810 Fake_glXSelectEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long mask)
2811 {
2812    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable);
2813    if (xmbuf) {
2814       /* Note: we'll never generate clobber events */
2815       xmbuf->selectedEvents = mask;
2816    }
2817 }
2818
2819
2820 static void
2821 Fake_glXGetSelectedEventSGIX(Display *dpy, GLXDrawable drawable, unsigned long *mask)
2822 {
2823    XMesaBuffer xmbuf = XMesaFindBuffer(dpy, drawable);
2824    if (xmbuf) {
2825       *mask = xmbuf->selectedEvents;
2826    }
2827    else {
2828       *mask = 0;
2829    }
2830 }
2831
2832
2833
2834 /*** GLX_SGI_cushion ***/
2835
2836 static void
2837 Fake_glXCushionSGI(Display *dpy, Window win, float cushion)
2838 {
2839    (void) dpy;
2840    (void) win;
2841    (void) cushion;
2842 }
2843
2844
2845
2846 /*** GLX_SGIX_video_resize ***/
2847
2848 static int
2849 Fake_glXBindChannelToWindowSGIX(Display *dpy, int screen, int channel , Window window)
2850 {
2851    (void) dpy;
2852    (void) screen;
2853    (void) channel;
2854    (void) window;
2855    return 0;
2856 }
2857
2858 static int
2859 Fake_glXChannelRectSGIX(Display *dpy, int screen, int channel, int x, int y, int w, int h)
2860 {
2861    (void) dpy;
2862    (void) screen;
2863    (void) channel;
2864    (void) x;
2865    (void) y;
2866    (void) w;
2867    (void) h;
2868    return 0;
2869 }
2870
2871 static int
2872 Fake_glXQueryChannelRectSGIX(Display *dpy, int screen, int channel, int *x, int *y, int *w, int *h)
2873 {
2874    (void) dpy;
2875    (void) screen;
2876    (void) channel;
2877    (void) x;
2878    (void) y;
2879    (void) w;
2880    (void) h;
2881    return 0;
2882 }
2883
2884 static int
2885 Fake_glXQueryChannelDeltasSGIX(Display *dpy, int screen, int channel, int *dx, int *dy, int *dw, int *dh)
2886 {
2887    (void) dpy;
2888    (void) screen;
2889    (void) channel;
2890    (void) dx;
2891    (void) dy;
2892    (void) dw;
2893    (void) dh;
2894    return 0;
2895 }
2896
2897 static int
2898 Fake_glXChannelRectSyncSGIX(Display *dpy, int screen, int channel, GLenum synctype)
2899 {
2900    (void) dpy;
2901    (void) screen;
2902    (void) channel;
2903    (void) synctype;
2904    return 0;
2905 }
2906
2907
2908
2909 /*** GLX_SGIX_dmbuffer **/
2910
2911 #if defined(_DM_BUFFER_H_)
2912 static Bool
2913 Fake_glXAssociateDMPbufferSGIX(Display *dpy, GLXPbufferSGIX pbuffer, DMparams *params, DMbuffer dmbuffer)
2914 {
2915    (void) dpy;
2916    (void) pbuffer;
2917    (void) params;
2918    (void) dmbuffer;
2919    return False;
2920 }
2921 #endif
2922
2923
2924 /*** GLX_SGIX_swap_group ***/
2925
2926 static void
2927 Fake_glXJoinSwapGroupSGIX(Display *dpy, GLXDrawable drawable, GLXDrawable member)
2928 {
2929    (void) dpy;
2930    (void) drawable;
2931    (void) member;
2932 }
2933
2934
2935
2936 /*** GLX_SGIX_swap_barrier ***/
2937
2938 static void
2939 Fake_glXBindSwapBarrierSGIX(Display *dpy, GLXDrawable drawable, int barrier)
2940 {
2941    (void) dpy;
2942    (void) drawable;
2943    (void) barrier;
2944 }
2945
2946 static Bool
2947 Fake_glXQueryMaxSwapBarriersSGIX(Display *dpy, int screen, int *max)
2948 {
2949    (void) dpy;
2950    (void) screen;
2951    (void) max;
2952    return False;
2953 }
2954
2955
2956
2957 /*** GLX_SUN_get_transparent_index ***/
2958
2959 static Status
2960 Fake_glXGetTransparentIndexSUN(Display *dpy, Window overlay, Window underlay, long *pTransparent)
2961 {
2962    (void) dpy;
2963    (void) overlay;
2964    (void) underlay;
2965    (void) pTransparent;
2966    return 0;
2967 }
2968
2969
2970
2971 /*** GLX_MESA_release_buffers ***/
2972
2973 /*
2974  * Release the depth, stencil, accum buffers attached to a GLXDrawable
2975  * (a window or pixmap) prior to destroying the GLXDrawable.
2976  */
2977 static Bool
2978 Fake_glXReleaseBuffersMESA( Display *dpy, GLXDrawable d )
2979 {
2980    XMesaBuffer b = XMesaFindBuffer(dpy, d);
2981    if (b) {
2982       XMesaDestroyBuffer(b);
2983       return True;
2984    }
2985    return False;
2986 }
2987
2988
2989
2990 /*** GLX_MESA_set_3dfx_mode ***/
2991
2992 static Bool
2993 Fake_glXSet3DfxModeMESA( int mode )
2994 {
2995    return XMesaSetFXmode( mode );
2996 }
2997
2998
2999
3000 /*** GLX_NV_vertex_array range ***/
3001 static void *
3002 Fake_glXAllocateMemoryNV( GLsizei size,
3003                           GLfloat readFrequency,
3004                           GLfloat writeFrequency,
3005                           GLfloat priority )
3006 {
3007    (void) size;
3008    (void) readFrequency;
3009    (void) writeFrequency;
3010    (void) priority;
3011    return NULL;
3012 }
3013
3014
3015 static void
3016 Fake_glXFreeMemoryNV( GLvoid *pointer )
3017 {
3018    (void) pointer;
3019 }
3020
3021
3022 /*** GLX_MESA_agp_offset ***/
3023
3024 static GLuint
3025 Fake_glXGetAGPOffsetMESA( const GLvoid *pointer )
3026 {
3027    (void) pointer;
3028    return ~0;
3029 }
3030
3031
3032 /*** GLX_EXT_texture_from_pixmap ***/
3033
3034 static void
3035 Fake_glXBindTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer,
3036                         const int *attrib_list)
3037 {
3038    XMesaBuffer b = XMesaFindBuffer(dpy, drawable);
3039    if (b)
3040       XMesaBindTexImage(dpy, b, buffer, attrib_list);
3041 }
3042
3043 static void
3044 Fake_glXReleaseTexImageEXT(Display *dpy, GLXDrawable drawable, int buffer)
3045 {
3046    XMesaBuffer b = XMesaFindBuffer(dpy, drawable);
3047    if (b)
3048       XMesaReleaseTexImage(dpy, b, buffer);
3049 }
3050
3051
3052 /* silence warning */
3053 extern struct _glxapi_table *_mesa_GetGLXDispatchTable(void);
3054
3055
3056 /**
3057  * Create a new GLX API dispatch table with its function pointers
3058  * initialized to point to Mesa's "fake" GLX API functions.
3059  * Note: there's a similar function (_real_GetGLXDispatchTable) that
3060  * returns a new dispatch table with all pointers initalized to point
3061  * to "real" GLX functions (which understand GLX wire protocol, etc).
3062  */
3063 struct _glxapi_table *
3064 _mesa_GetGLXDispatchTable(void)
3065 {
3066    static struct _glxapi_table glx;
3067
3068    /* be sure our dispatch table size <= libGL's table */
3069    {
3070       GLuint size = sizeof(struct _glxapi_table) / sizeof(void *);
3071       (void) size;
3072       assert(_glxapi_get_dispatch_table_size() >= size);
3073    }
3074
3075    /* initialize the whole table to no-ops */
3076    _glxapi_set_no_op_table(&glx);
3077
3078    /* now initialize the table with the functions I implement */
3079    glx.ChooseVisual = Fake_glXChooseVisual;
3080    glx.CopyContext = Fake_glXCopyContext;
3081    glx.CreateContext = Fake_glXCreateContext;
3082    glx.CreateGLXPixmap = Fake_glXCreateGLXPixmap;
3083    glx.DestroyContext = Fake_glXDestroyContext;
3084    glx.DestroyGLXPixmap = Fake_glXDestroyGLXPixmap;
3085    glx.GetConfig = Fake_glXGetConfig;
3086    /*glx.GetCurrentContext = Fake_glXGetCurrentContext;*/
3087    /*glx.GetCurrentDrawable = Fake_glXGetCurrentDrawable;*/
3088    glx.IsDirect = Fake_glXIsDirect;
3089    glx.MakeCurrent = Fake_glXMakeCurrent;
3090    glx.QueryExtension = Fake_glXQueryExtension;
3091    glx.QueryVersion = Fake_glXQueryVersion;
3092    glx.SwapBuffers = Fake_glXSwapBuffers;
3093    glx.UseXFont = Fake_glXUseXFont;
3094    glx.WaitGL = Fake_glXWaitGL;
3095    glx.WaitX = Fake_glXWaitX;
3096
3097    /*** GLX_VERSION_1_1 ***/
3098    glx.GetClientString = Fake_glXGetClientString;
3099    glx.QueryExtensionsString = Fake_glXQueryExtensionsString;
3100    glx.QueryServerString = Fake_glXQueryServerString;
3101
3102    /*** GLX_VERSION_1_2 ***/
3103    /*glx.GetCurrentDisplay = Fake_glXGetCurrentDisplay;*/
3104
3105    /*** GLX_VERSION_1_3 ***/
3106    glx.ChooseFBConfig = Fake_glXChooseFBConfig;
3107    glx.CreateNewContext = Fake_glXCreateNewContext;
3108    glx.CreatePbuffer = Fake_glXCreatePbuffer;
3109    glx.CreatePixmap = Fake_glXCreatePixmap;
3110    glx.CreateWindow = Fake_glXCreateWindow;
3111    glx.DestroyPbuffer = Fake_glXDestroyPbuffer;
3112    glx.DestroyPixmap = Fake_glXDestroyPixmap;
3113    glx.DestroyWindow = Fake_glXDestroyWindow;
3114    /*glx.GetCurrentReadDrawable = Fake_glXGetCurrentReadDrawable;*/
3115    glx.GetFBConfigAttrib = Fake_glXGetFBConfigAttrib;
3116    glx.GetFBConfigs = Fake_glXGetFBConfigs;
3117    glx.GetSelectedEvent = Fake_glXGetSelectedEvent;
3118    glx.GetVisualFromFBConfig = Fake_glXGetVisualFromFBConfig;
3119    glx.MakeContextCurrent = Fake_glXMakeContextCurrent;
3120    glx.QueryContext = Fake_glXQueryContext;
3121    glx.QueryDrawable = Fake_glXQueryDrawable;
3122    glx.SelectEvent = Fake_glXSelectEvent;
3123
3124    /*** GLX_SGI_swap_control ***/
3125    glx.SwapIntervalSGI = Fake_glXSwapIntervalSGI;
3126
3127    /*** GLX_SGI_video_sync ***/
3128    glx.GetVideoSyncSGI = Fake_glXGetVideoSyncSGI;
3129    glx.WaitVideoSyncSGI = Fake_glXWaitVideoSyncSGI;
3130
3131    /*** GLX_SGI_make_current_read ***/
3132    glx.MakeCurrentReadSGI = Fake_glXMakeCurrentReadSGI;
3133    /*glx.GetCurrentReadDrawableSGI = Fake_glXGetCurrentReadDrawableSGI;*/
3134
3135 /*** GLX_SGIX_video_source ***/
3136 #if defined(_VL_H)
3137    glx.CreateGLXVideoSourceSGIX = Fake_glXCreateGLXVideoSourceSGIX;
3138    glx.DestroyGLXVideoSourceSGIX = Fake_glXDestroyGLXVideoSourceSGIX;
3139 #endif
3140
3141    /*** GLX_EXT_import_context ***/
3142    glx.FreeContextEXT = Fake_glXFreeContextEXT;
3143    glx.GetContextIDEXT = Fake_glXGetContextIDEXT;
3144    /*glx.GetCurrentDisplayEXT = Fake_glXGetCurrentDisplayEXT;*/
3145    glx.ImportContextEXT = Fake_glXImportContextEXT;
3146    glx.QueryContextInfoEXT = Fake_glXQueryContextInfoEXT;
3147
3148    /*** GLX_SGIX_fbconfig ***/
3149    glx.GetFBConfigAttribSGIX = Fake_glXGetFBConfigAttribSGIX;
3150    glx.ChooseFBConfigSGIX = Fake_glXChooseFBConfigSGIX;
3151    glx.CreateGLXPixmapWithConfigSGIX = Fake_glXCreateGLXPixmapWithConfigSGIX;
3152    glx.CreateContextWithConfigSGIX = Fake_glXCreateContextWithConfigSGIX;
3153    glx.GetVisualFromFBConfigSGIX = Fake_glXGetVisualFromFBConfigSGIX;
3154    glx.GetFBConfigFromVisualSGIX = Fake_glXGetFBConfigFromVisualSGIX;
3155
3156    /*** GLX_SGIX_pbuffer ***/
3157    glx.CreateGLXPbufferSGIX = Fake_glXCreateGLXPbufferSGIX;
3158    glx.DestroyGLXPbufferSGIX = Fake_glXDestroyGLXPbufferSGIX;
3159    glx.QueryGLXPbufferSGIX = Fake_glXQueryGLXPbufferSGIX;
3160    glx.SelectEventSGIX = Fake_glXSelectEventSGIX;
3161    glx.GetSelectedEventSGIX = Fake_glXGetSelectedEventSGIX;
3162
3163    /*** GLX_SGI_cushion ***/
3164    glx.CushionSGI = Fake_glXCushionSGI;
3165
3166    /*** GLX_SGIX_video_resize ***/
3167    glx.BindChannelToWindowSGIX = Fake_glXBindChannelToWindowSGIX;
3168    glx.ChannelRectSGIX = Fake_glXChannelRectSGIX;
3169    glx.QueryChannelRectSGIX = Fake_glXQueryChannelRectSGIX;
3170    glx.QueryChannelDeltasSGIX = Fake_glXQueryChannelDeltasSGIX;
3171    glx.ChannelRectSyncSGIX = Fake_glXChannelRectSyncSGIX;
3172
3173    /*** GLX_SGIX_dmbuffer **/
3174 #if defined(_DM_BUFFER_H_)
3175    glx.AssociateDMPbufferSGIX = NULL;
3176 #endif
3177
3178    /*** GLX_SGIX_swap_group ***/
3179    glx.JoinSwapGroupSGIX = Fake_glXJoinSwapGroupSGIX;
3180
3181    /*** GLX_SGIX_swap_barrier ***/
3182    glx.BindSwapBarrierSGIX = Fake_glXBindSwapBarrierSGIX;
3183    glx.QueryMaxSwapBarriersSGIX = Fake_glXQueryMaxSwapBarriersSGIX;
3184
3185    /*** GLX_SUN_get_transparent_index ***/
3186    glx.GetTransparentIndexSUN = Fake_glXGetTransparentIndexSUN;
3187
3188    /*** GLX_MESA_copy_sub_buffer ***/
3189    glx.CopySubBufferMESA = Fake_glXCopySubBufferMESA;
3190
3191    /*** GLX_MESA_release_buffers ***/
3192    glx.ReleaseBuffersMESA = Fake_glXReleaseBuffersMESA;
3193
3194    /*** GLX_MESA_pixmap_colormap ***/
3195    glx.CreateGLXPixmapMESA = Fake_glXCreateGLXPixmapMESA;
3196
3197    /*** GLX_MESA_set_3dfx_mode ***/
3198    glx.Set3DfxModeMESA = Fake_glXSet3DfxModeMESA;
3199
3200    /*** GLX_NV_vertex_array_range ***/
3201    glx.AllocateMemoryNV = Fake_glXAllocateMemoryNV;
3202    glx.FreeMemoryNV = Fake_glXFreeMemoryNV;
3203
3204    /*** GLX_MESA_agp_offset ***/
3205    glx.GetAGPOffsetMESA = Fake_glXGetAGPOffsetMESA;
3206
3207    /*** GLX_EXT_texture_from_pixmap ***/
3208    glx.BindTexImageEXT = Fake_glXBindTexImageEXT;
3209    glx.ReleaseTexImageEXT = Fake_glXReleaseTexImageEXT;
3210
3211    return &glx;
3212 }