+++ /dev/null
-/*
- * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included
- * in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
- * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-
-/*
- * This program is a work-alike of the IRIX glxinfo program.
- * Command line options:
- * -t print wide table
- * -v print verbose information
- * -display DisplayName specify the X display to interogate
- * -b only print ID of "best" visual on screen 0
- * -i use indirect rendering connection only
- * -l print interesting OpenGL limits (added 5 Sep 2002)
- *
- * Brian Paul 26 January 2000
- */
-
-#define GLX_GLXEXT_PROTOTYPES
-
-#include <assert.h>
-#include <X11/Xlib.h>
-#include <X11/Xutil.h>
-#include <GL/gl.h>
-#include <GL/glx.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-
-#ifndef GLX_NONE_EXT
-#define GLX_NONE_EXT 0x8000
-#endif
-
-#ifndef GLX_TRANSPARENT_RGB
-#define GLX_TRANSPARENT_RGB 0x8008
-#endif
-
-#ifndef GLX_RGBA_BIT
-#define GLX_RGBA_BIT 0x00000001
-#endif
-
-#ifndef GLX_COLOR_INDEX_BIT
-#define GLX_COLOR_INDEX_BIT 0x00000002
-#endif
-
-typedef enum
-{
- Normal,
- Wide,
- Verbose
-} InfoMode;
-
-
-struct visual_attribs
-{
- /* X visual attribs */
- int id;
- int klass;
- int depth;
- int redMask, greenMask, blueMask;
- int colormapSize;
- int bitsPerRGB;
-
- /* GL visual attribs */
- int supportsGL;
- int drawableType;
- int transparentType;
- int transparentRedValue;
- int transparentGreenValue;
- int transparentBlueValue;
- int transparentAlphaValue;
- int transparentIndexValue;
- int bufferSize;
- int level;
- int render_type;
- int doubleBuffer;
- int stereo;
- int auxBuffers;
- int redSize, greenSize, blueSize, alphaSize;
- int depthSize;
- int stencilSize;
- int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
- int numSamples, numMultisample;
- int visualCaveat;
- int floatComponents;
- int srgb;
-};
-
-
-/*
- * Print a list of extensions, with word-wrapping.
- */
-static void
-print_extension_list(const char *ext)
-{
- const char *indentString = " ";
- const int indent = 4;
- const int max = 79;
- int width, i, j;
-
- if (!ext || !ext[0])
- return;
-
- width = indent;
- printf("%s", indentString);
- i = j = 0;
- while (1) {
- if (ext[j] == ' ' || ext[j] == 0) {
- /* found end of an extension name */
- const int len = j - i;
- if (width + len > max) {
- /* start a new line */
- printf("\n");
- width = indent;
- printf("%s", indentString);
- }
- /* print the extension name between ext[i] and ext[j] */
- while (i < j) {
- printf("%c", ext[i]);
- i++;
- }
- /* either we're all done, or we'll continue with next extension */
- width += len + 1;
- if (ext[j] == 0) {
- break;
- }
- else {
- i++;
- j++;
- if (ext[j] == 0)
- break;
- printf(", ");
- width += 2;
- }
- }
- j++;
- }
- printf("\n");
-}
-
-
-static void
-print_display_info(Display *dpy)
-{
- printf("name of display: %s\n", DisplayString(dpy));
-}
-
-
-/**
- * Print interesting limits for vertex/fragment programs.
- */
-static void
-print_program_limits(GLenum target)
-{
-#if defined(GL_ARB_vertex_program) || defined(GL_ARB_fragment_program)
- struct token_name {
- GLenum token;
- const char *name;
- };
- static const struct token_name common_limits[] = {
- { GL_MAX_PROGRAM_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_INSTRUCTIONS_ARB" },
- { GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB" },
- { GL_MAX_PROGRAM_TEMPORARIES_ARB, "GL_MAX_PROGRAM_TEMPORARIES_ARB" },
- { GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, "GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB" },
- { GL_MAX_PROGRAM_PARAMETERS_ARB, "GL_MAX_PROGRAM_PARAMETERS_ARB" },
- { GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, "GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB" },
- { GL_MAX_PROGRAM_ATTRIBS_ARB, "GL_MAX_PROGRAM_ATTRIBS_ARB" },
- { GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB, "GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB" },
- { GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB" },
- { GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB, "GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB" },
- { GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, "GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB" },
- { GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, "GL_MAX_PROGRAM_ENV_PARAMETERS_ARB" },
- { (GLenum) 0, NULL }
- };
- static const struct token_name fragment_limits[] = {
- { GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB" },
- { GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB" },
- { GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB" },
- { GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB" },
- { GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB" },
- { GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB, "GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB" },
- { (GLenum) 0, NULL }
- };
-
- PFNGLGETPROGRAMIVARBPROC GetProgramivARB_func = (PFNGLGETPROGRAMIVARBPROC)
- glXGetProcAddressARB((GLubyte *) "glGetProgramivARB");
-
- GLint max[1];
- int i;
-
- if (target == GL_VERTEX_PROGRAM_ARB) {
- printf(" GL_VERTEX_PROGRAM_ARB:\n");
- }
- else if (target == GL_FRAGMENT_PROGRAM_ARB) {
- printf(" GL_FRAGMENT_PROGRAM_ARB:\n");
- }
- else {
- return; /* something's wrong */
- }
-
- for (i = 0; common_limits[i].token; i++) {
- GetProgramivARB_func(target, common_limits[i].token, max);
- if (glGetError() == GL_NO_ERROR) {
- printf(" %s = %d\n", common_limits[i].name, max[0]);
- }
- }
- if (target == GL_FRAGMENT_PROGRAM_ARB) {
- for (i = 0; fragment_limits[i].token; i++) {
- GetProgramivARB_func(target, fragment_limits[i].token, max);
- if (glGetError() == GL_NO_ERROR) {
- printf(" %s = %d\n", fragment_limits[i].name, max[0]);
- }
- }
- }
-#endif /* GL_ARB_vertex_program / GL_ARB_fragment_program */
-}
-
-
-/**
- * Print interesting limits for vertex/fragment shaders.
- */
-static void
-print_shader_limits(GLenum target)
-{
- struct token_name {
- GLenum token;
- const char *name;
- };
-#if defined(GL_ARB_vertex_shader)
- static const struct token_name vertex_limits[] = {
- { GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, "GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB" },
- { GL_MAX_VARYING_FLOATS_ARB, "GL_MAX_VARYING_FLOATS_ARB" },
- { GL_MAX_VERTEX_ATTRIBS_ARB, "GL_MAX_VERTEX_ATTRIBS_ARB" },
- { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" },
- { GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" },
- { GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB" },
- { GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" },
- { (GLenum) 0, NULL }
- };
-#endif
-#if defined(GL_ARB_fragment_shader)
- static const struct token_name fragment_limits[] = {
- { GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB" },
- { GL_MAX_TEXTURE_COORDS_ARB, "GL_MAX_TEXTURE_COORDS_ARB" },
- { GL_MAX_TEXTURE_IMAGE_UNITS_ARB, "GL_MAX_TEXTURE_IMAGE_UNITS_ARB" },
- { (GLenum) 0, NULL }
- };
-#endif
- GLint max[1];
- int i;
-
-#if defined(GL_ARB_vertex_shader)
- if (target == GL_VERTEX_SHADER_ARB) {
- printf(" GL_VERTEX_SHADER_ARB:\n");
- for (i = 0; vertex_limits[i].token; i++) {
- glGetIntegerv(vertex_limits[i].token, max);
- if (glGetError() == GL_NO_ERROR) {
- printf(" %s = %d\n", vertex_limits[i].name, max[0]);
- }
- }
- }
-#endif
-#if defined(GL_ARB_fragment_shader)
- if (target == GL_FRAGMENT_SHADER_ARB) {
- printf(" GL_FRAGMENT_SHADER_ARB:\n");
- for (i = 0; fragment_limits[i].token; i++) {
- glGetIntegerv(fragment_limits[i].token, max);
- if (glGetError() == GL_NO_ERROR) {
- printf(" %s = %d\n", fragment_limits[i].name, max[0]);
- }
- }
- }
-#endif
-}
-
-
-/**
- * Print interesting OpenGL implementation limits.
- */
-static void
-print_limits(const char *extensions)
-{
- struct token_name {
- GLuint count;
- GLenum token;
- const char *name;
- };
- static const struct token_name limits[] = {
- { 1, GL_MAX_ATTRIB_STACK_DEPTH, "GL_MAX_ATTRIB_STACK_DEPTH" },
- { 1, GL_MAX_CLIENT_ATTRIB_STACK_DEPTH, "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH" },
- { 1, GL_MAX_CLIP_PLANES, "GL_MAX_CLIP_PLANES" },
- { 1, GL_MAX_COLOR_MATRIX_STACK_DEPTH, "GL_MAX_COLOR_MATRIX_STACK_DEPTH" },
- { 1, GL_MAX_ELEMENTS_VERTICES, "GL_MAX_ELEMENTS_VERTICES" },
- { 1, GL_MAX_ELEMENTS_INDICES, "GL_MAX_ELEMENTS_INDICES" },
- { 1, GL_MAX_EVAL_ORDER, "GL_MAX_EVAL_ORDER" },
- { 1, GL_MAX_LIGHTS, "GL_MAX_LIGHTS" },
- { 1, GL_MAX_LIST_NESTING, "GL_MAX_LIST_NESTING" },
- { 1, GL_MAX_MODELVIEW_STACK_DEPTH, "GL_MAX_MODELVIEW_STACK_DEPTH" },
- { 1, GL_MAX_NAME_STACK_DEPTH, "GL_MAX_NAME_STACK_DEPTH" },
- { 1, GL_MAX_PIXEL_MAP_TABLE, "GL_MAX_PIXEL_MAP_TABLE" },
- { 1, GL_MAX_PROJECTION_STACK_DEPTH, "GL_MAX_PROJECTION_STACK_DEPTH" },
- { 1, GL_MAX_TEXTURE_STACK_DEPTH, "GL_MAX_TEXTURE_STACK_DEPTH" },
- { 1, GL_MAX_TEXTURE_SIZE, "GL_MAX_TEXTURE_SIZE" },
- { 1, GL_MAX_3D_TEXTURE_SIZE, "GL_MAX_3D_TEXTURE_SIZE" },
- { 2, GL_MAX_VIEWPORT_DIMS, "GL_MAX_VIEWPORT_DIMS" },
- { 2, GL_ALIASED_LINE_WIDTH_RANGE, "GL_ALIASED_LINE_WIDTH_RANGE" },
- { 2, GL_SMOOTH_LINE_WIDTH_RANGE, "GL_SMOOTH_LINE_WIDTH_RANGE" },
- { 2, GL_ALIASED_POINT_SIZE_RANGE, "GL_ALIASED_POINT_SIZE_RANGE" },
- { 2, GL_SMOOTH_POINT_SIZE_RANGE, "GL_SMOOTH_POINT_SIZE_RANGE" },
-#if defined(GL_ARB_texture_cube_map)
- { 1, GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, "GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB" },
-#endif
-#if defined(GLX_NV_texture_rectangle)
- { 1, GL_MAX_RECTANGLE_TEXTURE_SIZE_NV, "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV" },
-#endif
-#if defined(GL_ARB_texture_compression)
- { 1, GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB, "GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB" },
-#endif
-#if defined(GL_ARB_multitexture)
- { 1, GL_MAX_TEXTURE_UNITS_ARB, "GL_MAX_TEXTURE_UNITS_ARB" },
-#endif
-#if defined(GL_EXT_texture_lod_bias)
- { 1, GL_MAX_TEXTURE_LOD_BIAS_EXT, "GL_MAX_TEXTURE_LOD_BIAS_EXT" },
-#endif
-#if defined(GL_EXT_texture_filter_anisotropic)
- { 1, GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, "GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT" },
-#endif
-#if defined(GL_ARB_draw_buffers)
- { 1, GL_MAX_DRAW_BUFFERS_ARB, "GL_MAX_DRAW_BUFFERS_ARB" },
-#endif
- { 0, (GLenum) 0, NULL }
- };
- GLint i, max[2];
-
- printf("OpenGL limits:\n");
- for (i = 0; limits[i].count; i++) {
- glGetIntegerv(limits[i].token, max);
- if (glGetError() == GL_NO_ERROR) {
- if (limits[i].count == 1)
- printf(" %s = %d\n", limits[i].name, max[0]);
- else /* XXX fix if we ever query something with more than 2 values */
- printf(" %s = %d, %d\n", limits[i].name, max[0], max[1]);
- }
- }
-
- /* these don't fit into the above mechanism, unfortunately */
- glGetConvolutionParameteriv(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_WIDTH, max);
- glGetConvolutionParameteriv(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_HEIGHT, max+1);
- if (glGetError() == GL_NONE) {
- printf(" GL_MAX_CONVOLUTION_WIDTH/HEIGHT = %d, %d\n", max[0], max[1]);
- }
-
-#if defined(GL_ARB_vertex_program)
- if (strstr(extensions, "GL_ARB_vertex_program")) {
- print_program_limits(GL_VERTEX_PROGRAM_ARB);
- }
-#endif
-#if defined(GL_ARB_fragment_program)
- if (strstr(extensions, "GL_ARB_fragment_program")) {
- print_program_limits(GL_FRAGMENT_PROGRAM_ARB);
- }
-#endif
-#if defined(GL_ARB_vertex_shader)
- if (strstr(extensions, "GL_ARB_vertex_shader")) {
- print_shader_limits(GL_VERTEX_SHADER_ARB);
- }
-#endif
-#if defined(GL_ARB_fragment_shader)
- if (strstr(extensions, "GL_ARB_fragment_shader")) {
- print_shader_limits(GL_FRAGMENT_SHADER_ARB);
- }
-#endif
-}
-
-
-static void
-print_screen_info(Display *dpy, int scrnum, Bool allowDirect, GLboolean limits)
-{
- Window win;
- int attribSingle[] = {
- GLX_RGBA,
- GLX_RED_SIZE, 1,
- GLX_GREEN_SIZE, 1,
- GLX_BLUE_SIZE, 1,
- None };
- int attribDouble[] = {
- GLX_RGBA,
- GLX_RED_SIZE, 1,
- GLX_GREEN_SIZE, 1,
- GLX_BLUE_SIZE, 1,
- GLX_DOUBLEBUFFER,
- None };
-
- XSetWindowAttributes attr;
- unsigned long mask;
- Window root;
- GLXContext ctx = NULL;
- XVisualInfo *visinfo;
- int width = 100, height = 100;
-
- root = RootWindow(dpy, scrnum);
-
- /*
- * Find a basic GLX visual. We'll then create a rendering context and
- * query various info strings.
- */
- visinfo = glXChooseVisual(dpy, scrnum, attribSingle);
- if (!visinfo)
- visinfo = glXChooseVisual(dpy, scrnum, attribDouble);
-
- if (visinfo)
- ctx = glXCreateContext( dpy, visinfo, NULL, allowDirect );
-
-#ifdef GLX_VERSION_1_3
- /* Try glXChooseFBConfig() if glXChooseVisual didn't work.
- * XXX when would that happen?
- */
- if (!visinfo) {
- int fbAttribSingle[] = {
- GLX_RENDER_TYPE, GLX_RGBA_BIT,
- GLX_RED_SIZE, 1,
- GLX_GREEN_SIZE, 1,
- GLX_BLUE_SIZE, 1,
- GLX_DOUBLEBUFFER, GL_FALSE,
- None };
- int fbAttribDouble[] = {
- GLX_RENDER_TYPE, GLX_RGBA_BIT,
- GLX_RED_SIZE, 1,
- GLX_GREEN_SIZE, 1,
- GLX_BLUE_SIZE, 1,
- GLX_DOUBLEBUFFER, GL_TRUE,
- None };
- GLXFBConfig *configs = NULL;
- int nConfigs;
-
- configs = glXChooseFBConfig(dpy, scrnum, fbAttribSingle, &nConfigs);
- if (!configs)
- configs = glXChooseFBConfig(dpy, scrnum, fbAttribDouble, &nConfigs);
-
- if (configs) {
- visinfo = glXGetVisualFromFBConfig(dpy, configs[0]);
- ctx = glXCreateNewContext(dpy, configs[0], GLX_RGBA_TYPE, NULL, allowDirect);
- XFree(configs);
- }
- }
-#endif
-
- if (!visinfo) {
- fprintf(stderr, "Error: couldn't find RGB GLX visual or fbconfig\n");
- return;
- }
-
- if (!ctx) {
- fprintf(stderr, "Error: glXCreateContext failed\n");
- XFree(visinfo);
- return;
- }
-
- attr.background_pixel = 0;
- attr.border_pixel = 0;
- attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
- attr.event_mask = StructureNotifyMask | ExposureMask;
- mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
- win = XCreateWindow(dpy, root, 0, 0, width, height,
- 0, visinfo->depth, InputOutput,
- visinfo->visual, mask, &attr);
-
- if (glXMakeCurrent(dpy, win, ctx)) {
- const char *serverVendor = glXQueryServerString(dpy, scrnum, GLX_VENDOR);
- const char *serverVersion = glXQueryServerString(dpy, scrnum, GLX_VERSION);
- const char *serverExtensions = glXQueryServerString(dpy, scrnum, GLX_EXTENSIONS);
- const char *clientVendor = glXGetClientString(dpy, GLX_VENDOR);
- const char *clientVersion = glXGetClientString(dpy, GLX_VERSION);
- const char *clientExtensions = glXGetClientString(dpy, GLX_EXTENSIONS);
- const char *glxExtensions = glXQueryExtensionsString(dpy, scrnum);
- const char *glVendor = (const char *) glGetString(GL_VENDOR);
- const char *glRenderer = (const char *) glGetString(GL_RENDERER);
- const char *glVersion = (const char *) glGetString(GL_VERSION);
- const char *glExtensions = (const char *) glGetString(GL_EXTENSIONS);
- int glxVersionMajor;
- int glxVersionMinor;
- char *displayName = NULL;
- char *colon = NULL, *period = NULL;
-
- if (! glXQueryVersion( dpy, & glxVersionMajor, & glxVersionMinor )) {
- fprintf(stderr, "Error: glXQueryVersion failed\n");
- exit(1);
- }
-
- /* Strip the screen number from the display name, if present. */
- if (!(displayName = (char *) malloc(strlen(DisplayString(dpy)) + 1))) {
- fprintf(stderr, "Error: malloc() failed\n");
- exit(1);
- }
- strcpy(displayName, DisplayString(dpy));
- colon = strrchr(displayName, ':');
- if (colon) {
- period = strchr(colon, '.');
- if (period)
- *period = '\0';
- }
- printf("display: %s screen: %d\n", displayName, scrnum);
- free(displayName);
- printf("direct rendering: ");
- if (glXIsDirect(dpy, ctx)) {
- printf("Yes\n");
- } else {
- if (!allowDirect) {
- printf("No (-i specified)\n");
- } else if (getenv("LIBGL_ALWAYS_INDIRECT")) {
- printf("No (LIBGL_ALWAYS_INDIRECT set)\n");
- } else {
- printf("No (If you want to find out why, try setting "
- "LIBGL_DEBUG=verbose)\n");
- }
- }
- printf("server glx vendor string: %s\n", serverVendor);
- printf("server glx version string: %s\n", serverVersion);
- printf("server glx extensions:\n");
- print_extension_list(serverExtensions);
- printf("client glx vendor string: %s\n", clientVendor);
- printf("client glx version string: %s\n", clientVersion);
- printf("client glx extensions:\n");
- print_extension_list(clientExtensions);
- printf("GLX version: %u.%u\n", glxVersionMajor, glxVersionMinor);
- printf("GLX extensions:\n");
- print_extension_list(glxExtensions);
- printf("OpenGL vendor string: %s\n", glVendor);
- printf("OpenGL renderer string: %s\n", glRenderer);
- printf("OpenGL version string: %s\n", glVersion);
-#ifdef GL_VERSION_2_0
- if (glVersion[0] >= '2' && glVersion[1] == '.') {
- char *v = (char *) glGetString(GL_SHADING_LANGUAGE_VERSION);
- printf("OpenGL shading language version string: %s\n", v);
- }
-#endif
-
- printf("OpenGL extensions:\n");
- print_extension_list(glExtensions);
- if (limits)
- print_limits(glExtensions);
- }
- else {
- fprintf(stderr, "Error: glXMakeCurrent failed\n");
- }
-
- glXDestroyContext(dpy, ctx);
- XFree(visinfo);
- XDestroyWindow(dpy, win);
-}
-
-
-static const char *
-visual_class_name(int cls)
-{
- switch (cls) {
- case StaticColor:
- return "StaticColor";
- case PseudoColor:
- return "PseudoColor";
- case StaticGray:
- return "StaticGray";
- case GrayScale:
- return "GrayScale";
- case TrueColor:
- return "TrueColor";
- case DirectColor:
- return "DirectColor";
- default:
- return "";
- }
-}
-
-static const char *
-visual_drawable_type(int type)
-{
- static char buffer[256], *p;
- const static struct { int bit; const char *name; } bits[] = {
- { GLX_WINDOW_BIT, "window" },
- { GLX_PIXMAP_BIT, "pixmap" },
- { GLX_PBUFFER_BIT, "pbuffer" }
- };
- int i;
-
- p = buffer;
- for (i = 0; i < 3; i++) {
- if (p > buffer)
- *p++ = ',';
- if (type & bits[i].bit)
- strcpy(p, bits[i].name);
- p += strlen(bits[i].name);
- }
-
- return buffer;
-}
-
-static const char *
-visual_class_abbrev(int cls)
-{
- switch (cls) {
- case StaticColor:
- return "sc";
- case PseudoColor:
- return "pc";
- case StaticGray:
- return "sg";
- case GrayScale:
- return "gs";
- case TrueColor:
- return "tc";
- case DirectColor:
- return "dc";
- default:
- return "";
- }
-}
-
-static const char *
-visual_render_type_name(int type)
-{
- switch (type) {
- case GLX_RGBA_BIT:
- return "rgba";
- case GLX_COLOR_INDEX_BIT:
- return "ci";
- case GLX_RGBA_BIT | GLX_COLOR_INDEX_BIT:
- return "rgba|ci";
- default:
- return "";
- }
-}
-
-static const char *
-caveat_string(int caveat)
-{
- switch (caveat) {
-#ifdef GLX_EXT_visual_rating
- case GLX_SLOW_VISUAL_EXT:
- return "Slow";
- case GLX_NON_CONFORMANT_VISUAL_EXT:
- return "Ncon";
- case GLX_NONE_EXT:
- /* fall-through */
-#endif
- case 0:
- /* fall-through */
- default:
- return "None";
- }
-}
-
-
-static GLboolean
-get_visual_attribs(Display *dpy, XVisualInfo *vInfo,
- struct visual_attribs *attribs)
-{
- const char *ext = glXQueryExtensionsString(dpy, vInfo->screen);
- int rgba;
-
- memset(attribs, 0, sizeof(struct visual_attribs));
-
- attribs->id = vInfo->visualid;
-#if defined(__cplusplus) || defined(c_plusplus)
- attribs->klass = vInfo->c_class;
-#else
- attribs->klass = vInfo->class;
-#endif
- attribs->depth = vInfo->depth;
- attribs->redMask = vInfo->red_mask;
- attribs->greenMask = vInfo->green_mask;
- attribs->blueMask = vInfo->blue_mask;
- attribs->colormapSize = vInfo->colormap_size;
- attribs->bitsPerRGB = vInfo->bits_per_rgb;
-
- if (glXGetConfig(dpy, vInfo, GLX_USE_GL, &attribs->supportsGL) != 0 ||
- !attribs->supportsGL)
- return GL_FALSE;
- glXGetConfig(dpy, vInfo, GLX_BUFFER_SIZE, &attribs->bufferSize);
- glXGetConfig(dpy, vInfo, GLX_LEVEL, &attribs->level);
- glXGetConfig(dpy, vInfo, GLX_RGBA, &rgba);
- if (rgba)
- attribs->render_type = GLX_RGBA_BIT;
- else
- attribs->render_type = GLX_COLOR_INDEX_BIT;
-
- glXGetConfig(dpy, vInfo, GLX_DRAWABLE_TYPE, &attribs->drawableType);
- glXGetConfig(dpy, vInfo, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
- glXGetConfig(dpy, vInfo, GLX_STEREO, &attribs->stereo);
- glXGetConfig(dpy, vInfo, GLX_AUX_BUFFERS, &attribs->auxBuffers);
- glXGetConfig(dpy, vInfo, GLX_RED_SIZE, &attribs->redSize);
- glXGetConfig(dpy, vInfo, GLX_GREEN_SIZE, &attribs->greenSize);
- glXGetConfig(dpy, vInfo, GLX_BLUE_SIZE, &attribs->blueSize);
- glXGetConfig(dpy, vInfo, GLX_ALPHA_SIZE, &attribs->alphaSize);
- glXGetConfig(dpy, vInfo, GLX_DEPTH_SIZE, &attribs->depthSize);
- glXGetConfig(dpy, vInfo, GLX_STENCIL_SIZE, &attribs->stencilSize);
- glXGetConfig(dpy, vInfo, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
- glXGetConfig(dpy, vInfo, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
- glXGetConfig(dpy, vInfo, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
- glXGetConfig(dpy, vInfo, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
-
- /* get transparent pixel stuff */
- glXGetConfig(dpy, vInfo,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
- if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
- glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
- glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
- glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
- glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
- }
- else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
- glXGetConfig(dpy, vInfo, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
- }
-
- /* multisample attribs */
-#ifdef GLX_ARB_multisample
- if (ext && strstr(ext, "GLX_ARB_multisample")) {
- glXGetConfig(dpy, vInfo, GLX_SAMPLE_BUFFERS_ARB, &attribs->numMultisample);
- glXGetConfig(dpy, vInfo, GLX_SAMPLES_ARB, &attribs->numSamples);
- }
-#endif
- else {
- attribs->numSamples = 0;
- attribs->numMultisample = 0;
- }
-
-#if defined(GLX_EXT_visual_rating)
- if (ext && strstr(ext, "GLX_EXT_visual_rating")) {
- glXGetConfig(dpy, vInfo, GLX_VISUAL_CAVEAT_EXT, &attribs->visualCaveat);
- }
- else {
- attribs->visualCaveat = GLX_NONE_EXT;
- }
-#else
- attribs->visualCaveat = 0;
-#endif
-
-#if defined(GLX_EXT_framebuffer_sRGB)
- if (ext && strstr(ext, "GLX_EXT_framebuffer_sRGB")) {
- glXGetConfig(dpy, vInfo, GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, &attribs->srgb);
- }
-#endif
-
- return GL_TRUE;
-}
-
-#ifdef GLX_VERSION_1_3
-
-static int
-glx_token_to_visual_class(int visual_type)
-{
- switch (visual_type) {
- case GLX_TRUE_COLOR:
- return TrueColor;
- case GLX_DIRECT_COLOR:
- return DirectColor;
- case GLX_PSEUDO_COLOR:
- return PseudoColor;
- case GLX_STATIC_COLOR:
- return StaticColor;
- case GLX_GRAY_SCALE:
- return GrayScale;
- case GLX_STATIC_GRAY:
- return StaticGray;
- case GLX_NONE:
- default:
- return None;
- }
-}
-
-static GLboolean
-get_fbconfig_attribs(Display *dpy, GLXFBConfig fbconfig,
- struct visual_attribs *attribs)
-{
- const char *ext = glXQueryExtensionsString(dpy, 0);
- int visual_type;
- XVisualInfo *vInfo;
-
- memset(attribs, 0, sizeof(struct visual_attribs));
-
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_FBCONFIG_ID, &attribs->id);
-
- vInfo = glXGetVisualFromFBConfig(dpy, fbconfig);
-
- if (vInfo != NULL) {
- attribs->depth = vInfo->depth;
- attribs->redMask = vInfo->red_mask;
- attribs->greenMask = vInfo->green_mask;
- attribs->blueMask = vInfo->blue_mask;
- attribs->colormapSize = vInfo->colormap_size;
- attribs->bitsPerRGB = vInfo->bits_per_rgb;
- }
-
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_X_VISUAL_TYPE, &visual_type);
- attribs->klass = glx_token_to_visual_class(visual_type);
-
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_DRAWABLE_TYPE, &attribs->drawableType);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_BUFFER_SIZE, &attribs->bufferSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_LEVEL, &attribs->level);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_RENDER_TYPE, &attribs->render_type);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_DOUBLEBUFFER, &attribs->doubleBuffer);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_STEREO, &attribs->stereo);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_AUX_BUFFERS, &attribs->auxBuffers);
-
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_RED_SIZE, &attribs->redSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_GREEN_SIZE, &attribs->greenSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_BLUE_SIZE, &attribs->blueSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_ALPHA_SIZE, &attribs->alphaSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_DEPTH_SIZE, &attribs->depthSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_STENCIL_SIZE, &attribs->stencilSize);
-
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_RED_SIZE, &attribs->accumRedSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_GREEN_SIZE, &attribs->accumGreenSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_BLUE_SIZE, &attribs->accumBlueSize);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_ACCUM_ALPHA_SIZE, &attribs->accumAlphaSize);
-
- /* get transparent pixel stuff */
- glXGetFBConfigAttrib(dpy, fbconfig,GLX_TRANSPARENT_TYPE, &attribs->transparentType);
- if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_RED_VALUE, &attribs->transparentRedValue);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_GREEN_VALUE, &attribs->transparentGreenValue);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_BLUE_VALUE, &attribs->transparentBlueValue);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_ALPHA_VALUE, &attribs->transparentAlphaValue);
- }
- else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_TRANSPARENT_INDEX_VALUE, &attribs->transparentIndexValue);
- }
-
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLE_BUFFERS, &attribs->numMultisample);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_SAMPLES, &attribs->numSamples);
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_CONFIG_CAVEAT, &attribs->visualCaveat);
-
-#if defined(GLX_NV_float_buffer)
- if (ext && strstr(ext, "GLX_NV_float_buffer")) {
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_FLOAT_COMPONENTS_NV, &attribs->floatComponents);
- }
-#endif
-#if defined(GLX_ARB_fbconfig_float)
- if (ext && strstr(ext, "GLX_ARB_fbconfig_float")) {
- if (attribs->render_type & GLX_RGBA_FLOAT_BIT_ARB) {
- attribs->floatComponents = True;
- }
- }
-#endif
-
-#if defined(GLX_EXT_framebuffer_sRGB)
- if (ext && strstr(ext, "GLX_EXT_framebuffer_sRGB")) {
- glXGetFBConfigAttrib(dpy, fbconfig, GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT, &attribs->srgb);
- }
-#endif
- return GL_TRUE;
-}
-
-#endif
-
-
-
-static void
-print_visual_attribs_verbose(const struct visual_attribs *attribs)
-{
- printf("Visual ID: %x depth=%d class=%s, type=%s\n",
- attribs->id, attribs->depth, visual_class_name(attribs->klass),
- visual_drawable_type(attribs->drawableType));
- printf(" bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n",
- attribs->bufferSize, attribs->level,
- visual_render_type_name(attribs->render_type),
- attribs->doubleBuffer, attribs->stereo);
- printf(" rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d float=%c sRGB=%c\n",
- attribs->redSize, attribs->greenSize,
- attribs->blueSize, attribs->alphaSize,
- attribs->floatComponents ? 'Y' : 'N',
- attribs->srgb ? 'Y' : 'N');
- printf(" auxBuffers=%d depthSize=%d stencilSize=%d\n",
- attribs->auxBuffers, attribs->depthSize, attribs->stencilSize);
- printf(" accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n",
- attribs->accumRedSize, attribs->accumGreenSize,
- attribs->accumBlueSize, attribs->accumAlphaSize);
- printf(" multiSample=%d multiSampleBuffers=%d\n",
- attribs->numSamples, attribs->numMultisample);
-#ifdef GLX_EXT_visual_rating
- if (attribs->visualCaveat == GLX_NONE_EXT || attribs->visualCaveat == 0)
- printf(" visualCaveat=None\n");
- else if (attribs->visualCaveat == GLX_SLOW_VISUAL_EXT)
- printf(" visualCaveat=Slow\n");
- else if (attribs->visualCaveat == GLX_NON_CONFORMANT_VISUAL_EXT)
- printf(" visualCaveat=Nonconformant\n");
-#endif
- if (attribs->transparentType == GLX_NONE) {
- printf(" Opaque.\n");
- }
- else if (attribs->transparentType == GLX_TRANSPARENT_RGB) {
- printf(" Transparent RGB: Red=%d Green=%d Blue=%d Alpha=%d\n",attribs->transparentRedValue,attribs->transparentGreenValue,attribs->transparentBlueValue,attribs->transparentAlphaValue);
- }
- else if (attribs->transparentType == GLX_TRANSPARENT_INDEX) {
- printf(" Transparent index=%d\n",attribs->transparentIndexValue);
- }
-}
-
-
-static void
-print_visual_attribs_short_header(void)
-{
- printf(" visual x bf lv rg d st colorbuffer sr ax dp st accumbuffer ms cav\n");
- printf(" id dep cl sp sz l ci b ro r g b a F gb bf th cl r g b a ns b eat\n");
- printf("----------------------------------------------------------------------------\n");
-}
-
-
-static void
-print_visual_attribs_short(const struct visual_attribs *attribs)
-{
- const char *caveat = caveat_string(attribs->visualCaveat);
-
- printf("0x%03x %2d %2s %2d %3d %2d %c%c %c %c %2d %2d %2d %2d %c %c %2d %2d %2d",
- attribs->id,
- attribs->depth,
- visual_class_abbrev(attribs->klass),
- attribs->transparentType != GLX_NONE,
- attribs->bufferSize,
- attribs->level,
- (attribs->render_type & GLX_RGBA_BIT) ? 'r' : ' ',
- (attribs->render_type & GLX_COLOR_INDEX_BIT) ? 'c' : ' ',
- attribs->doubleBuffer ? 'y' : '.',
- attribs->stereo ? 'y' : '.',
- attribs->redSize, attribs->greenSize,
- attribs->blueSize, attribs->alphaSize,
- attribs->floatComponents ? 'f' : '.',
- attribs->srgb ? 's' : '.',
- attribs->auxBuffers,
- attribs->depthSize,
- attribs->stencilSize
- );
-
- printf(" %2d %2d %2d %2d %2d %1d %s\n",
- attribs->accumRedSize, attribs->accumGreenSize,
- attribs->accumBlueSize, attribs->accumAlphaSize,
- attribs->numSamples, attribs->numMultisample,
- caveat
- );
-}
-
-
-static void
-print_visual_attribs_long_header(void)
-{
- printf("Vis Vis Visual Trans buff lev render DB ste r g b a s aux dep ste accum buffer MS MS \n");
- printf(" ID Depth Type parent size el type reo sz sz sz sz flt rgb buf th ncl r g b a num bufs caveats\n");
- printf("--------------------------------------------------------------------------------------------------------------------\n");
-}
-
-
-static void
-print_visual_attribs_long(const struct visual_attribs *attribs)
-{
- const char *caveat = caveat_string(attribs->visualCaveat);
-
- printf("0x%3x %2d %-11s %2d %3d %2d %4s %3d %3d %3d %3d %3d %3d",
- attribs->id,
- attribs->depth,
- visual_class_name(attribs->klass),
- attribs->transparentType != GLX_NONE,
- attribs->bufferSize,
- attribs->level,
- visual_render_type_name(attribs->render_type),
- attribs->doubleBuffer,
- attribs->stereo,
- attribs->redSize, attribs->greenSize,
- attribs->blueSize, attribs->alphaSize
- );
-
- printf(" %c %c %3d %4d %2d %3d %3d %3d %3d %2d %2d %6s\n",
- attribs->floatComponents ? 'f' : '.',
- attribs->srgb ? 's' : '.',
- attribs->auxBuffers,
- attribs->depthSize,
- attribs->stencilSize,
- attribs->accumRedSize, attribs->accumGreenSize,
- attribs->accumBlueSize, attribs->accumAlphaSize,
- attribs->numSamples, attribs->numMultisample,
- caveat
- );
-}
-
-
-static void
-print_visual_info(Display *dpy, int scrnum, InfoMode mode)
-{
- XVisualInfo theTemplate;
- XVisualInfo *visuals;
- int numVisuals, numGlxVisuals;
- long mask;
- int i;
- struct visual_attribs attribs;
-
- /* get list of all visuals on this screen */
- theTemplate.screen = scrnum;
- mask = VisualScreenMask;
- visuals = XGetVisualInfo(dpy, mask, &theTemplate, &numVisuals);
-
- numGlxVisuals = 0;
- for (i = 0; i < numVisuals; i++) {
- if (get_visual_attribs(dpy, &visuals[i], &attribs))
- numGlxVisuals++;
- }
-
- if (numGlxVisuals == 0)
- return;
-
- printf("%d GLX Visuals\n", numGlxVisuals);
-
- if (mode == Normal)
- print_visual_attribs_short_header();
- else if (mode == Wide)
- print_visual_attribs_long_header();
-
- for (i = 0; i < numVisuals; i++) {
- if (!get_visual_attribs(dpy, &visuals[i], &attribs))
- continue;
-
- if (mode == Verbose)
- print_visual_attribs_verbose(&attribs);
- else if (mode == Normal)
- print_visual_attribs_short(&attribs);
- else if (mode == Wide)
- print_visual_attribs_long(&attribs);
- }
- printf("\n");
-
- XFree(visuals);
-}
-
-#ifdef GLX_VERSION_1_3
-
-static void
-print_fbconfig_info(Display *dpy, int scrnum, InfoMode mode)
-{
- int numFBConfigs = 0;
- struct visual_attribs attribs;
- GLXFBConfig *fbconfigs;
- int i;
-
- /* get list of all fbconfigs on this screen */
- fbconfigs = glXGetFBConfigs(dpy, scrnum, &numFBConfigs);
-
- if (numFBConfigs == 0) {
- XFree(fbconfigs);
- return;
- }
-
- printf("%d GLXFBConfigs:\n", numFBConfigs);
- if (mode == Normal)
- print_visual_attribs_short_header();
- else if (mode == Wide)
- print_visual_attribs_long_header();
-
- for (i = 0; i < numFBConfigs; i++) {
- get_fbconfig_attribs(dpy, fbconfigs[i], &attribs);
-
- if (mode == Verbose)
- print_visual_attribs_verbose(&attribs);
- else if (mode == Normal)
- print_visual_attribs_short(&attribs);
- else if (mode == Wide)
- print_visual_attribs_long(&attribs);
- }
- printf("\n");
-
- XFree(fbconfigs);
-}
-
-#endif
-
-/*
- * Stand-alone Mesa doesn't really implement the GLX protocol so it
- * doesn't really know the GLX attributes associated with an X visual.
- * The first time a visual is presented to Mesa's pseudo-GLX it
- * attaches ancilliary buffers to it (like depth and stencil).
- * But that usually only works if glXChooseVisual is used.
- * This function calls glXChooseVisual() to sort of "prime the pump"
- * for Mesa's GLX so that the visuals that get reported actually
- * reflect what applications will see.
- * This has no effect when using true GLX.
- */
-static void
-mesa_hack(Display *dpy, int scrnum)
-{
- static int attribs[] = {
- GLX_RGBA,
- GLX_RED_SIZE, 1,
- GLX_GREEN_SIZE, 1,
- GLX_BLUE_SIZE, 1,
- GLX_DEPTH_SIZE, 1,
- GLX_STENCIL_SIZE, 1,
- GLX_ACCUM_RED_SIZE, 1,
- GLX_ACCUM_GREEN_SIZE, 1,
- GLX_ACCUM_BLUE_SIZE, 1,
- GLX_ACCUM_ALPHA_SIZE, 1,
- GLX_DOUBLEBUFFER,
- None
- };
- XVisualInfo *visinfo;
-
- visinfo = glXChooseVisual(dpy, scrnum, attribs);
- if (visinfo)
- XFree(visinfo);
-}
-
-
-/*
- * Examine all visuals to find the so-called best one.
- * We prefer deepest RGBA buffer with depth, stencil and accum
- * that has no caveats.
- */
-static int
-find_best_visual(Display *dpy, int scrnum)
-{
- XVisualInfo theTemplate;
- XVisualInfo *visuals;
- int numVisuals;
- long mask;
- int i;
- struct visual_attribs bestVis;
-
- /* get list of all visuals on this screen */
- theTemplate.screen = scrnum;
- mask = VisualScreenMask;
- visuals = XGetVisualInfo(dpy, mask, &theTemplate, &numVisuals);
-
- /* init bestVis with first visual info */
- get_visual_attribs(dpy, &visuals[0], &bestVis);
-
- /* try to find a "better" visual */
- for (i = 1; i < numVisuals; i++) {
- struct visual_attribs vis;
-
- get_visual_attribs(dpy, &visuals[i], &vis);
-
- /* always skip visuals with caveats */
- if (vis.visualCaveat != GLX_NONE_EXT)
- continue;
-
- /* see if this vis is better than bestVis */
- if ((!bestVis.supportsGL && vis.supportsGL) ||
- (bestVis.visualCaveat != GLX_NONE_EXT) ||
- (!(bestVis.render_type & GLX_RGBA_BIT) && (vis.render_type & GLX_RGBA_BIT)) ||
- (!bestVis.doubleBuffer && vis.doubleBuffer) ||
- (bestVis.redSize < vis.redSize) ||
- (bestVis.greenSize < vis.greenSize) ||
- (bestVis.blueSize < vis.blueSize) ||
- (bestVis.alphaSize < vis.alphaSize) ||
- (bestVis.depthSize < vis.depthSize) ||
- (bestVis.stencilSize < vis.stencilSize) ||
- (bestVis.accumRedSize < vis.accumRedSize)) {
- /* found a better visual */
- bestVis = vis;
- }
- }
-
- XFree(visuals);
-
- return bestVis.id;
-}
-
-
-static void
-usage(void)
-{
- printf("Usage: glxinfo [-v] [-t] [-h] [-i] [-b] [-display <dname>]\n");
- printf("\t-v: Print visuals info in verbose form.\n");
- printf("\t-t: Print verbose table.\n");
- printf("\t-display <dname>: Print GLX visuals on specified server.\n");
- printf("\t-h: This information.\n");
- printf("\t-i: Force an indirect rendering context.\n");
- printf("\t-b: Find the 'best' visual and print its number.\n");
- printf("\t-l: Print interesting OpenGL limits.\n");
-}
-
-
-int
-main(int argc, char *argv[])
-{
- char *displayName = NULL;
- Display *dpy;
- int numScreens, scrnum;
- InfoMode mode = Normal;
- GLboolean findBest = GL_FALSE;
- GLboolean limits = GL_FALSE;
- Bool allowDirect = True;
- int i;
-
- for (i = 1; i < argc; i++) {
- if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) {
- displayName = argv[i + 1];
- i++;
- }
- else if (strcmp(argv[i], "-t") == 0) {
- mode = Wide;
- }
- else if (strcmp(argv[i], "-v") == 0) {
- mode = Verbose;
- }
- else if (strcmp(argv[i], "-b") == 0) {
- findBest = GL_TRUE;
- }
- else if (strcmp(argv[i], "-i") == 0) {
- allowDirect = False;
- }
- else if (strcmp(argv[i], "-l") == 0) {
- limits = GL_TRUE;
- }
- else if (strcmp(argv[i], "-h") == 0) {
- usage();
- return 0;
- }
- else {
- printf("Unknown option `%s'\n", argv[i]);
- usage();
- return 0;
- }
- }
-
- dpy = XOpenDisplay(displayName);
- if (!dpy) {
- fprintf(stderr, "Error: unable to open display %s\n", XDisplayName(displayName));
- return -1;
- }
-
- if (findBest) {
- int b;
- mesa_hack(dpy, 0);
- b = find_best_visual(dpy, 0);
- printf("%d\n", b);
- }
- else {
- numScreens = ScreenCount(dpy);
- print_display_info(dpy);
- for (scrnum = 0; scrnum < numScreens; scrnum++) {
- mesa_hack(dpy, scrnum);
- print_screen_info(dpy, scrnum, allowDirect, limits);
- printf("\n");
- print_visual_info(dpy, scrnum, mode);
-#ifdef GLX_VERSION_1_3
- print_fbconfig_info(dpy, scrnum, mode);
-#endif
- if (scrnum + 1 < numScreens)
- printf("\n\n");
- }
- }
-
- XCloseDisplay(dpy);
-
- return 0;
-}
projects / mesa.git / blobdiff