path: root/utils/visual-gl.c

/* xscreensaver, Copyright © 1999-2021 Jamie Zawinski <jwz@jwz.org>
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation.  No representations are made about the suitability of this
 * software for any purpose.  It is provided "as is" without express or 
 * implied warranty.
 */

/* This file contains code for picking the best visual for GL programs by
   actually asking the GL library to figure it out for us.  The code in
   visual.c might do a good job of this on most systems, but not on most
   high end 3D cards (e.g., Silicon Graphics or nVidia.)

   There exists information about visuals which is available to GL, but
   which is not available via Xlib calls.  So the only way to know
   which visual to use (other than impirically) is to actually call
   glXChooseVisual().
 */

#include "utils.h"
#include "resources.h"

#ifdef HAVE_GL
# include <GL/gl.h>
# ifdef HAVE_EGL
#  include <EGL/egl.h>
#  include <EGL/eglext.h>
# else
#  include <GL/glx.h>
# endif
#endif /* HAVE_GL */

#include "visual.h"		/* after EGL/egl.h */

#undef countof
#define countof(x) (sizeof(x)/sizeof(*(x)))


extern char *progname;


Visual *
get_gl_visual (Screen *screen)
{
#ifdef HAVE_GL

  Display *dpy = DisplayOfScreen (screen);

# ifdef HAVE_EGL

  Visual *v;
  EGLint vid;
  EGLDisplay *egl_display;
  EGLConfig egl_config = 0;
  int egl_major = -1, egl_minor = -1;

  /* This is re-used, no need to close it. */
  egl_display = eglGetDisplay ((EGLNativeDisplayType) dpy);
  if (!egl_display)
    {
      fprintf (stderr, "%s: eglGetDisplay failed\n", progname);
      return 0;
    }

  if (! eglInitialize (egl_display, &egl_major, &egl_minor))
    {
      fprintf (stderr, "%s: eglInitialize failed\n", progname);
      abort();
    }

  /* Get the best EGL config on any visual, then see what visual it used. */
  get_egl_config (dpy, egl_display, -1, &egl_config);
  if (!egl_config) abort();

  if (!eglGetConfigAttrib (egl_display, egl_config,
                           EGL_NATIVE_VISUAL_ID, &vid))
    {
      fprintf (stderr, "%s: EGL: no native visual ID\n", progname);
      abort();
    }
        
  v = id_to_visual (screen, vid);
  if (!v)
    {
      fprintf (stderr, "%s: EGL: no X11 visual 0x%x\n", progname, vid);
      abort();
    }

    return v;

# else  /* !HAVE_EGL -- GLX */

  int screen_num = screen_number (screen);

# define R GLX_RED_SIZE
# define G GLX_GREEN_SIZE
# define B GLX_BLUE_SIZE
# define A GLX_ALPHA_SIZE
# define D GLX_DEPTH_SIZE
# define I GLX_BUFFER_SIZE
# define DB GLX_DOUBLEBUFFER
# define ST GLX_STENCIL_SIZE

# if defined(GLX_SAMPLE_BUFFERS) /* Needs to come before GL_SAMPLE_BUFFERS */
#  define SB GLX_SAMPLE_BUFFERS
#  define SM GLX_SAMPLES
# elif defined(GLX_SAMPLE_BUFFERS_ARB)
#  define SB GLX_SAMPLE_BUFFERS_ARB
#  define SM GLX_SAMPLES_ARB
# elif defined(GLX_SAMPLE_BUFFERS_SGIS)
#  define SB GLX_SAMPLE_BUFFERS_SGIS
#  define SM GLX_SAMPLES_SGIS
# elif defined(GL_SAMPLE_BUFFERS)
#  define SB GL_SAMPLE_BUFFERS
#  define SM GL_SAMPLES
# endif

  int attrs[][40] = {
# ifdef SB				  /* rgba double stencil multisample */
   { GLX_RGBA, R,8, G,8, B,8, A,8, D,8, DB, ST,1, SB,1, SM,8, 0 },
   { GLX_RGBA, R,8, G,8, B,8, A,8, D,8, DB, ST,1, SB,1, SM,6, 0 },
   { GLX_RGBA, R,8, G,8, B,8, A,8, D,8, DB, ST,1, SB,1, SM,4, 0 },
   { GLX_RGBA, R,8, G,8, B,8, A,8, D,8, DB, ST,1, SB,1, SM,2, 0 },
#  define SB_COUNT 4 /* #### Kludgey count of preceeding lines! */
# endif
   { GLX_RGBA, R,8, G,8, B,8, A,8, D,8, DB, ST,1, 0 }, /* rgba double stencil */
   { GLX_RGBA, R,8, G,8, B,8,      D,8, DB, ST,1, 0 }, /* rgb  double stencil */
   { GLX_RGBA, R,4, G,4, B,4,      D,4, DB, ST,1, 0 },
   { GLX_RGBA, R,2, G,2, B,2,      D,2, DB, ST,1, 0 },
   { GLX_RGBA, R,8, G,8, B,8, A,8, D,8, DB,       0 }, /* rgba double */
   { GLX_RGBA, R,8, G,8, B,8,      D,8, DB,       0 }, /* rgb  double */
   { GLX_RGBA, R,4, G,4, B,4,      D,4, DB,       0 },
   { GLX_RGBA, R,2, G,2, B,2,      D,2, DB,       0 },
   { GLX_RGBA, R,8, G,8, B,8, A,8, D,8,           0 }, /* rgba single */
   { GLX_RGBA, R,8, G,8, B,8,      D,8,           0 }, /* rgb  single */
   { GLX_RGBA, R,4, G,4, B,4,      D,4,           0 },
   { GLX_RGBA, R,2, G,2, B,2,      D,2,           0 },
   { I, 8,                         D,8, DB,       0 }, /* cmap double */
   { I, 4,                         D,4, DB,       0 },
   { I, 8,                         D,8,           0 }, /* cmap single */
   { I, 4,                         D,4,           0 },
   { GLX_RGBA, R,1, G,1, B,1,      D,1,           0 }  /* monochrome */
  };

  int i = 0;

# ifdef SB
  if (! get_boolean_resource (dpy, "multiSample", "MultiSample"))
    i = SB_COUNT;  /* skip over the multibuffer entries in 'attrs' */
# endif /* SB */

  for (; i < sizeof(attrs)/sizeof(*attrs); i++)
    {
      XVisualInfo *vi = glXChooseVisual (dpy, screen_num, attrs[i]);
      if (vi)
        {
          Visual *v = vi->visual;
          XFree (vi);
          /* describe_gl_visual (stderr, screen, v, False); */
          return v;
        }
    }

# endif  /* !HAVE_EGL -- GLX */
#endif /* !HAVE_GL */

  return 0;
}


#ifdef HAVE_EGL
/* An X11 "visual" is an object that encapsulates the available display
   formats: color mapping, depth and so on.  So is a GLE "config".
   So why isn't there a one-to-one mapping between visuals and configs?
   Once again, I can only assume the answer is that the people responsible
   for every post-2002 version of the OpenGL specification are incompetent.

   Under GLX, there will be multiple X11 visuals that appear (and behave)
   identically to X11 programs, code but that have different GL parameters.
   Two RGB visuals might have different alpha, depth, or stencil sizes,
   for example, that would matter to a GL program but not to an X11 program.

   But EGL has dozens of 'configs' for each visual, so we can't just pass
   around a Window and a Visual to describe the display parameters: we need
   to pass around the 'config' as well.  Or, do what we do here, have both
   sides use the same code to convert a visual to the best 'config'.
   (It goes down a list of parameter settings, from higher quality to lower,
   and takes the first config that matches.)

   SGI solved this problem in like 1988, and like so many things, GLES went
   and fucked it all up again.
 */
void
get_egl_config (Display *dpy, EGLDisplay *egl_display,
                EGLint x11_visual_id, EGLConfig *egl_config)
{
# define COMMON \
    EGL_SURFACE_TYPE,      EGL_WINDOW_BIT, \
    EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER
# define R EGL_RED_SIZE
# define G EGL_GREEN_SIZE
# define B EGL_BLUE_SIZE
# define A EGL_ALPHA_SIZE
# define D EGL_DEPTH_SIZE
# define I EGL_BUFFER_SIZE
# define ST EGL_STENCIL_SIZE
# define SB EGL_SAMPLE_BUFFERS
# define SM EGL_SAMPLES

  const EGLint templates[][40] = {
# ifdef SB
   { COMMON, R,8, G,8, B,8, A,8, D,8, ST,1, SB,1, SM,8, EGL_NONE },
   { COMMON, R,8, G,8, B,8, A,8, D,8, ST,1, SB,1, SM,6, EGL_NONE },
   { COMMON, R,8, G,8, B,8, A,8, D,8, ST,1, SB,1, SM,4, EGL_NONE },
   { COMMON, R,8, G,8, B,8, A,8, D,8, ST,1, SB,1, SM,2, EGL_NONE },
#  define SB_COUNT 4 /* #### Kludgey count of preceeding lines! */
# endif
   { COMMON, R,8, G,8, B,8, A,8, D,8, ST,1, EGL_NONE }, /* rgba stencil */
   { COMMON, R,8, G,8, B,8,      D,8, ST,1, EGL_NONE }, /* rgb  stencil */
   { COMMON, R,4, G,4, B,4,      D,4, ST,1, EGL_NONE },
   { COMMON, R,2, G,2, B,2,      D,2, ST,1, EGL_NONE },
   { COMMON, R,8, G,8, B,8, A,8, D,8,       EGL_NONE }, /* rgba */
   { COMMON, R,8, G,8, B,8,      D,8,       EGL_NONE }, /* rgb  */
   { COMMON, R,4, G,4, B,4,      D,4,       EGL_NONE },
   { COMMON, R,2, G,2, B,2,      D,2,       EGL_NONE },
   { COMMON, R,1, G,1, B,1,      D,1,       EGL_NONE }  /* monochrome */
  };
  EGLint attrs[40];
  EGLint nconfig;
  int i, j, k, iter, pass;
  Bool glslp;

  i = 0;
# ifdef SB
  if (! get_boolean_resource (dpy, "multiSample", "MultiSample"))
    i = SB_COUNT;  /* skip over the multibuffer entries in 'attrs' */
# endif /* SB */

  glslp = get_boolean_resource (dpy, "prefersGLSL", "PrefersGLSL");
  iter = (glslp ? 2 : 1);

  *egl_config = 0;
  for (pass = 0; pass < iter; pass++)
    {
      for (; i < countof(templates); i++)
        {
          for (j = 0, k = 0; templates[i][j] != EGL_NONE; j += 2)
            {
              attrs[k++] = templates[i][j];
              attrs[k++] = templates[i][j+1];
            }

          attrs[k++] = EGL_RENDERABLE_TYPE;
# ifdef HAVE_GLES3
          if (glslp && pass == 0)
            attrs[k++] = EGL_OPENGL_ES3_BIT;
          else
            attrs[k++] = EGL_OPENGL_ES_BIT;
# elif defined(HAVE_JWZGLES)
          attrs[k++] = EGL_OPENGL_ES_BIT;
# else
          attrs[k++] = EGL_OPENGL_BIT;
# endif

          if (x11_visual_id != -1)
            {
              attrs[k++] = EGL_NATIVE_VISUAL_ID;
              attrs[k++] = x11_visual_id;
            }

          attrs[k++] = EGL_NONE;

          nconfig = -1;
          if (eglChooseConfig (egl_display, attrs, egl_config, 1, &nconfig)
              && nconfig == 1)
            break;
        }
      if (i < countof(templates))
        break;
    }

  if (! *egl_config)
    {
      fprintf (stderr, "%s: eglChooseConfig: no configs found\n", progname);
      abort();
    }
}
#endif /* HAVE_EGL */


void
describe_gl_visual (FILE *f, Screen *screen, Visual *visual,
                    Bool private_cmap_p)
{
  describe_visual (f, screen, visual, private_cmap_p);

#ifdef HAVE_GL
  {
# ifdef HAVE_EGL
    EGLDisplay *egl_display;
    EGLConfig config = 0;
# else  /* !HAVE_EGL -- GLX */
    int status;
    int value = False;
# endif /* !HAVE_EGL -- GLX */

    Display *dpy = DisplayOfScreen (screen);
    XVisualInfo vi_in, *vi_out;
    int out_count;

    vi_in.screen = screen_number (screen);
    vi_in.visualid = XVisualIDFromVisual (visual);
    vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualIDMask),
                             &vi_in, &out_count);
    if (! vi_out) abort ();

# ifdef HAVE_EGL

    /* This is re-used, no need to close it. */
    egl_display = eglGetPlatformDisplay (EGL_PLATFORM_X11_KHR,
                                         (EGLNativeDisplayType) dpy, NULL);
    if (!egl_display)
      {
        fprintf (stderr, "%s: eglGetPlatformDisplay failed\n", progname);
        return;
      }

    get_egl_config (dpy, egl_display, vi_out->visualid, &config);
    if (!config)
      {
        fprintf (stderr, "%s: no matching EGL config for X11 visual 0x%lx\n",
                 progname, vi_out->visualid);
        abort();
      }

    {
      int i;
      const struct { int hexp; EGLint i; const char *s; } fields[] = {
        { 1, EGL_CONFIG_ID,		"config ID:"	 },
        { 1, EGL_CONFIG_CAVEAT,		"caveat:"	 },
        { 1, EGL_CONFORMANT,		"conformant:"	 },
        { 0, EGL_COLOR_BUFFER_TYPE,	"buffer type:"	 },
        { 0, EGL_RED_SIZE,		"color size:"	 },
        { 0, EGL_TRANSPARENT_RED_VALUE,	"transparency:"	 },
        { 0, EGL_BUFFER_SIZE,		"buffer size:"	 },
        { 0, EGL_DEPTH_SIZE,		"depth size:"	 },
        { 0, EGL_LUMINANCE_SIZE,	"lum size:"	 },
        { 0, EGL_STENCIL_SIZE,		"stencil size:"	 },
        { 0, EGL_ALPHA_MASK_SIZE,	"alpha mask:"	 },
        { 0, EGL_LEVEL,			"level:"	 },
        { 0, EGL_SAMPLES,		"samples:"	 },
        { 0, EGL_SAMPLE_BUFFERS,	"sample bufs:"	 },
        { 0, EGL_NATIVE_RENDERABLE,	"native render:" },
        { 1, EGL_NATIVE_VISUAL_TYPE,	"native type:"	 },
        { 1, EGL_RENDERABLE_TYPE,	"render type:"	 },
        { 0, EGL_SURFACE_TYPE,		"surface type:"	 },
        { 0, EGL_BIND_TO_TEXTURE_RGB,	"bind RGB:"	 },
        { 0, EGL_BIND_TO_TEXTURE_RGBA,	"bind RGBA:"	 },
        { 0, EGL_MAX_PBUFFER_WIDTH,	"buffer width:"	 },
        { 0, EGL_MAX_PBUFFER_HEIGHT,	"buffer height:" },
        { 0, EGL_MAX_PBUFFER_PIXELS,	"buffer pixels:" },
        { 0, EGL_MAX_SWAP_INTERVAL,	"max swap:"	 },
        { 0, EGL_MIN_SWAP_INTERVAL,	"min swap:"	 },
        };
      EGLint r=0, g=0, b=0, a=0, tt=0, tr=0, tg=0, tb=0;
      eglGetConfigAttrib (egl_display, config, EGL_RED_SIZE,   &r);
      eglGetConfigAttrib (egl_display, config, EGL_GREEN_SIZE, &g);
      eglGetConfigAttrib (egl_display, config, EGL_BLUE_SIZE,  &b);
      eglGetConfigAttrib (egl_display, config, EGL_ALPHA_SIZE, &a);
      eglGetConfigAttrib (egl_display, config, EGL_TRANSPARENT_TYPE, &tt);
      eglGetConfigAttrib (egl_display, config, EGL_TRANSPARENT_RED_VALUE,  &tr);
      eglGetConfigAttrib (egl_display, config, EGL_TRANSPARENT_GREEN_VALUE,&tg);
      eglGetConfigAttrib (egl_display, config, EGL_TRANSPARENT_BLUE_VALUE, &tb);
      for (i = 0; i < countof(fields); i++)
        {
          EGLint v = 0;
          char s[100];
          eglGetConfigAttrib (egl_display, config, fields[i].i, &v);
          if (fields[i].i == EGL_RED_SIZE)
            sprintf (s, "%d, %d, %d, %d", r, g, b, a);
          else if (fields[i].i == EGL_TRANSPARENT_RED_VALUE && tt != EGL_NONE)
            sprintf (s, "%d, %d, %d", tr, tg, tb);
          else if (fields[i].i == EGL_CONFIG_CAVEAT)
            strcpy (s, (v == EGL_NONE ? "none" :
                        v == EGL_SLOW_CONFIG ? "slow" :
# ifdef EGL_NON_CONFORMANT
                        v == EGL_NON_CONFORMANT ? "non-conformant" :
# endif
                        "???"));
          else if (fields[i].i == EGL_COLOR_BUFFER_TYPE)
            strcpy (s, (v == EGL_RGB_BUFFER ? "RGB" :
                        v == EGL_LUMINANCE_BUFFER ? "luminance" :
                        "???"));
          else if (fields[i].i == EGL_CONFORMANT ||
                   fields[i].i == EGL_RENDERABLE_TYPE)
            {
              sprintf (s, "0x%02x", v);
              if (v & EGL_OPENGL_BIT)     strcat (s, " OpenGL");
              if (v & EGL_OPENGL_ES_BIT)  strcat (s, " GLES-1.x");
              if (v & EGL_OPENGL_ES2_BIT) strcat (s, " GLES-2.0");
# ifdef EGL_OPENGL_ES3_BIT
              if (v & EGL_OPENGL_ES3_BIT) strcat (s, " GLES-3.0");
# endif
              if (v & EGL_OPENVG_BIT)     strcat (s, " OpenVG");
            }
          else if (fields[i].hexp)
            sprintf (s, "0x%02x", v);
          else if (v)
            sprintf (s, "%d", v);
          else
            *s = 0;

          if (*s) fprintf (f, "    EGL %-14s %s\n", fields[i].s, s);
        }
    }

# else /* !HAVE_EGL -- GLX */

    status = glXGetConfig (dpy, vi_out, GLX_USE_GL, &value);

    if (status == GLX_NO_EXTENSION)
      /* dpy does not support the GLX extension. */
      return;

    if (status == GLX_BAD_VISUAL || value == False)
      /* this visual does not support GLX. */
      return;
    
    if (!glXGetConfig (dpy, vi_out, GLX_LEVEL, &value) &&
        value != 0)
      fprintf (f, "    GLX level:         %d\n", value);

    if (!glXGetConfig (dpy, vi_out, GLX_RGBA, &value) && value)
      {
        int r=0, g=0, b=0, a=0;
        glXGetConfig (dpy, vi_out, GLX_RED_SIZE,   &r);
        glXGetConfig (dpy, vi_out, GLX_GREEN_SIZE, &g);
        glXGetConfig (dpy, vi_out, GLX_BLUE_SIZE,  &b);
        glXGetConfig (dpy, vi_out, GLX_ALPHA_SIZE, &a);
        fprintf (f, "    GLX type:          RGBA (%2d, %2d, %2d, %2d)\n",
                 r, g, b, a);

        r=0, g=0, b=0, a=0;
        glXGetConfig (dpy, vi_out, GLX_ACCUM_RED_SIZE,   &r);
        glXGetConfig (dpy, vi_out, GLX_ACCUM_GREEN_SIZE, &g);
        glXGetConfig (dpy, vi_out, GLX_ACCUM_BLUE_SIZE,  &b);
        glXGetConfig (dpy, vi_out, GLX_ACCUM_ALPHA_SIZE, &a);
        fprintf (f, "    GLX accum:         RGBA (%2d, %2d, %2d, %2d)\n",
                 r, g, b, a);
      }
    else
      {
        value = 0;
        glXGetConfig (dpy, vi_out, GLX_BUFFER_SIZE, &value);
        fprintf (f, "    GLX type:          indexed (%d)\n", value);
      }

# ifndef  GLX_NONE_EXT       /* Hooray for gratuitious name changes. */
#  define GLX_NONE_EXT                    GLX_NONE
#  define GLX_TRANSPARENT_TYPE_EXT        GLX_TRANSPARENT_TYPE
#  define GLX_TRANSPARENT_INDEX_EXT       GLX_TRANSPARENT_INDEX
#  define GLX_TRANSPARENT_INDEX_VALUE_EXT GLX_TRANSPARENT_INDEX_VALUE
#  define GLX_TRANSPARENT_RGB_EXT         GLX_TRANSPARENT_RGB
#  define GLX_TRANSPARENT_RED_VALUE_EXT   GLX_TRANSPARENT_RED_VALUE
#  define GLX_TRANSPARENT_GREEN_VALUE_EXT GLX_TRANSPARENT_GREEN_VALUE
#  define GLX_TRANSPARENT_BLUE_VALUE_EXT  GLX_TRANSPARENT_BLUE_VALUE
#  define GLX_TRANSPARENT_ALPHA_VALUE_EXT GLX_TRANSPARENT_ALPHA_VALUE
# endif

# ifdef GLX_VISUAL_CAVEAT_EXT
    if (!glXGetConfig (dpy, vi_out, GLX_VISUAL_CAVEAT_EXT, &value) &&
        value != GLX_NONE_EXT)
#   ifdef GLX_NON_CONFORMANT_EXT
      fprintf (f, "    GLX rating:        %s\n",
               (value == GLX_NONE_EXT ? "none" :
                value == GLX_SLOW_VISUAL_EXT ? "slow" :
                value == GLX_NON_CONFORMANT_EXT ? "non-conformant" :
                "???");
#   else      
      fprintf (f, "    GLX rating:        %s\n",
               (value == GLX_NONE_EXT ? "none" :
                value == GLX_SLOW_VISUAL_EXT ? "slow" :
                "???"));
#   endif /* GLX_NON_CONFORMANT_EXT */
# endif /* GLX_VISUAL_CAVEAT_EXT */

    if (!glXGetConfig (dpy, vi_out, GLX_DOUBLEBUFFER, &value))
      fprintf (f, "    GLX double-buffer: %s\n", (value ? "yes" : "no"));

    if (!glXGetConfig (dpy, vi_out, GLX_STEREO, &value) &&
        value)
      fprintf (f, "    GLX stereo:        %s\n", (value ? "yes" : "no"));

    if (!glXGetConfig (dpy, vi_out, GLX_AUX_BUFFERS, &value) &&
        value != 0)
      fprintf (f, "    GLX aux buffers:   %d\n", value);

    if (!glXGetConfig (dpy, vi_out, GLX_DEPTH_SIZE, &value))
      fprintf (f, "    GLX depth size:    %d\n", value);

    if (!glXGetConfig (dpy, vi_out, GLX_STENCIL_SIZE, &value) &&
        value != 0)
      fprintf (f, "    GLX stencil size:  %d\n", value);

# ifdef SB  /* GL_SAMPLE_BUFFERS || GLX_SAMPLE_BUFFERS_* */
    if (!glXGetConfig (dpy, vi_out, SB, &value) &&
        value != 0)
      {
        int bufs = value;
        if (!glXGetConfig (dpy, vi_out, SM, &value))
          fprintf (f, "    GLX multisample:   %d, %d\n", bufs, value);
      }
# endif  /* GL_SAMPLE_BUFFERS || GLX_SAMPLE_BUFFERS_* */

    if (!glXGetConfig (dpy, vi_out, GLX_TRANSPARENT_TYPE_EXT, &value) &&
        value != GLX_NONE_EXT)
      {
        if (value == GLX_NONE_EXT)
          fprintf (f, "    GLX transparency:  none\n");
        else if (value == GLX_TRANSPARENT_INDEX_EXT)
          {
            if (!glXGetConfig (dpy, vi_out, GLX_TRANSPARENT_INDEX_VALUE_EXT,
                               &value))
              fprintf (f, "    GLX transparency:  indexed (%d)\n", value);
          }
        else if (value == GLX_TRANSPARENT_RGB_EXT)
          {
            int r=0, g=0, b=0, a=0;
            glXGetConfig (dpy, vi_out, GLX_TRANSPARENT_RED_VALUE_EXT,   &r);
            glXGetConfig (dpy, vi_out, GLX_TRANSPARENT_GREEN_VALUE_EXT, &g);
            glXGetConfig (dpy, vi_out, GLX_TRANSPARENT_BLUE_VALUE_EXT,  &b);
            glXGetConfig (dpy, vi_out, GLX_TRANSPARENT_ALPHA_VALUE_EXT, &a);
            fprintf (f, "    GLX transparency:  RGBA (%2d, %2d, %2d, %2d)\n",
                     r, g, b, a);
          }
      }
# endif /* !HAVE_EGL */
  }
#endif  /* HAVE_GL */
}


Bool
validate_gl_visual (FILE *out, Screen *screen, const char *window_desc,
                    Visual *visual)
{
#ifdef HAVE_GL
# ifndef HAVE_EGL
  int status;
  int value = False;
  unsigned int id;
# endif

  Display *dpy = DisplayOfScreen (screen);
  XVisualInfo vi_in, *vi_out;
  int out_count;

  vi_in.screen = screen_number (screen);
  vi_in.visualid = XVisualIDFromVisual (visual);
  vi_out = XGetVisualInfo (dpy, (VisualScreenMask | VisualIDMask),
                             &vi_in, &out_count);
  if (! vi_out) abort ();

# ifndef HAVE_EGL
  status = glXGetConfig (dpy, vi_out, GLX_USE_GL, &value);

  id = (unsigned int) vi_out->visualid;
  XFree ((char *) vi_out);

  if (status == GLX_NO_EXTENSION)
    {
      fprintf (out, "%s: display \"%s\" does not support the GLX extension.\n",
               progname, DisplayString (dpy));
      return False;
    }
  else if (status == GLX_BAD_VISUAL || value == False)
    {
      fprintf (out,
               "%s: %s's visual 0x%x does not support the GLX extension.\n",
               progname, window_desc, id);
      return False;
    }
  else
# endif /* !HAVE_EGL */
    {
      return True;
    }

#else  /* !HAVE_GL */

  fprintf (out, "%s: GL support was not compiled in to this program.\n",
           progname);
  return False;

#endif  /* !HAVE_GL */
}