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