progs/wgl/wglinfo.c - third_party/mesa - Git at Google

 /*
  * Copyright (C) 2009  VMware, Inc.
  * 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
  * THE AUTHORS 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 GLX glxinfo program.
  * Command line options:
  *  -t                     print wide table
  *  -v                     print verbose information
  *  -b                     only print ID of "best" visual on screen 0
  *  -l                     print interesting OpenGL limits (added 5 Sep 2002)
  */

 #include <windows.h>

 #include <GL/gl.h>
 #include <GL/glext.h>
 #include <GL/wglext.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>


 typedef enum
 {
    Normal,
    Wide,
    Verbose
 } InfoMode;


 /*
  * 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(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(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");
 }


 /**
  * 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 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" },
       { 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)
       wglGetProcAddress("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; limits[i].token; i++) {
       GetProgramivARB_func(target, limits[i].token, max);
       if (glGetError() == GL_NO_ERROR) {
          printf("        %s = %d\n", 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]);
       }
    }

 #if defined(GL_EXT_convolution)
    {
       PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC glGetConvolutionParameterivEXT_func =
          (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)wglGetProcAddress("glGetConvolutionParameterivEXT");
       if(glGetConvolutionParameterivEXT_func) {
          /* these don't fit into the above mechanism, unfortunately */
          glGetConvolutionParameterivEXT_func(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_WIDTH, max);
          glGetConvolutionParameterivEXT_func(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]);
          }
       }
    }
 #endif

 #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 LRESULT CALLBACK
 WndProc(HWND hWnd,
         UINT uMsg,
         WPARAM wParam,
         LPARAM lParam )
 {
    switch (uMsg) {
    case WM_DESTROY:
       PostQuitMessage(0);
       break;
    default:
       return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }

    return 0;
 }


 static void
 print_screen_info(HDC _hdc, GLboolean limits)
 {
    WNDCLASS wc;
    HWND win;
    HGLRC ctx;
    int visinfo;
    HDC hdc;
    PIXELFORMATDESCRIPTOR pfd;

    memset(&wc, 0, sizeof wc);
    wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.lpfnWndProc = WndProc;
    wc.lpszClassName = "wglinfo";
    wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
    RegisterClass(&wc);

    win = CreateWindowEx(0,
                         wc.lpszClassName,
                         "wglinfo",
                         WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         CW_USEDEFAULT,
                         NULL,
                         NULL,
                         wc.hInstance,
                         NULL);
    if (!win) {
       fprintf(stderr, "Couldn't create window");
       return;
    }

    hdc = GetDC(win);
    if (!hdc) {
       fprintf(stderr, "Couldn't obtain HDC");
       return;
    }

    pfd.cColorBits = 3;
    pfd.cRedBits = 1;
    pfd.cGreenBits = 1;
    pfd.cBlueBits = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
    pfd.iLayerType = PFD_MAIN_PLANE;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.nSize = sizeof(pfd);
    pfd.nVersion = 1;

    visinfo = ChoosePixelFormat(hdc, &pfd);
    if (!visinfo) {
       pfd.dwFlags |= PFD_DOUBLEBUFFER;
       visinfo = ChoosePixelFormat(hdc, &pfd);
    }

    if (!visinfo) {
       fprintf(stderr, "Error: couldn't find RGB WGL visual\n");
       return;
    }

    SetPixelFormat(hdc, visinfo, &pfd);
    ctx = wglCreateContext(hdc);
    if (!ctx) {
       fprintf(stderr, "Error: wglCreateContext failed\n");
       return;
    }

    if (wglMakeCurrent(hdc, ctx)) {
 #if defined(WGL_ARB_extensions_string)
       PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB_func =
          (PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB");
 #endif
       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);

 #if defined(WGL_ARB_extensions_string)
       if(wglGetExtensionsStringARB_func) {
          const char *wglExtensions = wglGetExtensionsStringARB_func(hdc);
          if(wglExtensions) {
             printf("WGL extensions:\n");
             print_extension_list(wglExtensions);
          }
       }
 #endif
       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: wglMakeCurrent failed\n");
    }

    DestroyWindow(win);
 }


 static const char *
 visual_render_type_name(BYTE iPixelType)
 {
    switch (iPixelType) {
       case PFD_TYPE_RGBA:
          return "rgba";
       case PFD_TYPE_COLORINDEX:
          return "ci";
       default:
          return "";
    }
 }

 static void
 print_visual_attribs_verbose(int iPixelFormat, LPPIXELFORMATDESCRIPTOR ppfd)
 {
    printf("Visual ID: %x  generic=%d  native=%d\n",
           iPixelFormat,
           ppfd->dwFlags & PFD_GENERIC_FORMAT ? 1 : 0,
           ppfd->dwFlags & PFD_DRAW_TO_WINDOW ? 1 : 0);
    printf("    bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n",
           0 /* ppfd->bufferSize */, 0 /* ppfd->level */,
 	  visual_render_type_name(ppfd->iPixelType),
           ppfd->dwFlags & PFD_DOUBLEBUFFER ? 1 : 0,
           ppfd->dwFlags & PFD_STEREO ? 1 : 0);
    printf("    rgba: cRedBits=%d cGreenBits=%d cBlueBits=%d cAlphaBits=%d\n",
           ppfd->cRedBits, ppfd->cGreenBits,
           ppfd->cBlueBits, ppfd->cAlphaBits);
    printf("    cAuxBuffers=%d cDepthBits=%d cStencilBits=%d\n",
           ppfd->cAuxBuffers, ppfd->cDepthBits, ppfd->cStencilBits);
    printf("    accum: cRedBits=%d cGreenBits=%d cBlueBits=%d cAlphaBits=%d\n",
           ppfd->cAccumRedBits, ppfd->cAccumGreenBits,
           ppfd->cAccumBlueBits, ppfd->cAccumAlphaBits);
    printf("    multiSample=%d  multiSampleBuffers=%d\n",
           0 /* ppfd->numSamples */, 0 /* ppfd->numMultisample */);
 }


 static void
 print_visual_attribs_short_header(void)
 {
  printf("   visual   x  bf lv rg d st colorbuffer ax dp st accumbuffer  ms  cav\n");
  printf(" id gen nat sp sz l  ci b ro  r  g  b  a bf th cl  r  g  b  a ns b eat\n");
  printf("-----------------------------------------------------------------------\n");
 }


 static void
 print_visual_attribs_short(int iPixelFormat, LPPIXELFORMATDESCRIPTOR ppfd)
 {
    char *caveat = "None";

    printf("0x%02x %2d %2d %2d %2d %2d %c%c %c  %c %2d %2d %2d %2d %2d %2d %2d",
           iPixelFormat,
           ppfd->dwFlags & PFD_GENERIC_FORMAT ? 1 : 0,
           ppfd->dwFlags & PFD_DRAW_TO_WINDOW ? 1 : 0,
           0,
           0 /* ppfd->bufferSize */,
           0 /* ppfd->level */,
           ppfd->iPixelType == PFD_TYPE_RGBA ? 'r' : ' ',
           ppfd->iPixelType == PFD_TYPE_COLORINDEX ? 'c' : ' ',
           ppfd->dwFlags & PFD_DOUBLEBUFFER ? 'y' : '.',
           ppfd->dwFlags & PFD_STEREO ? 'y' : '.',
           ppfd->cRedBits, ppfd->cGreenBits,
           ppfd->cBlueBits, ppfd->cAlphaBits,
           ppfd->cAuxBuffers,
           ppfd->cDepthBits,
           ppfd->cStencilBits
           );

    printf(" %2d %2d %2d %2d %2d %1d %s\n",
           ppfd->cAccumRedBits, ppfd->cAccumGreenBits,
           ppfd->cAccumBlueBits, ppfd->cAccumAlphaBits,
           0 /* ppfd->numSamples */, 0 /* ppfd->numMultisample */,
           caveat
           );
 }


 static void
 print_visual_attribs_long_header(void)
 {
  printf("Vis  Vis   Visual Trans  buff lev render DB ste  r   g   b   a  aux dep ste  accum buffers  MS   MS\n");
  printf(" ID Depth   Type  parent size el   type     reo sz  sz  sz  sz  buf th  ncl  r   g   b   a  num bufs\n");
  printf("----------------------------------------------------------------------------------------------------\n");
 }


 static void
 print_visual_attribs_long(int iPixelFormat, LPPIXELFORMATDESCRIPTOR ppfd)
 {
    printf("0x%2x %2d %11d %2d     %2d %2d  %4s %3d %3d %3d %3d %3d %3d",
           iPixelFormat,
           ppfd->dwFlags & PFD_GENERIC_FORMAT ? 1 : 0,
           ppfd->dwFlags & PFD_DRAW_TO_WINDOW ? 1 : 0,
           0,
           0 /* ppfd->bufferSize */,
           0 /* ppfd->level */,
           visual_render_type_name(ppfd->iPixelType),
           ppfd->dwFlags & PFD_DOUBLEBUFFER ? 1 : 0,
           ppfd->dwFlags & PFD_STEREO ? 1 : 0,
           ppfd->cRedBits, ppfd->cGreenBits,
           ppfd->cBlueBits, ppfd->cAlphaBits
           );

    printf(" %3d %4d %2d %3d %3d %3d %3d  %2d  %2d\n",
           ppfd->cAuxBuffers,
           ppfd->cDepthBits,
           ppfd->cStencilBits,
           ppfd->cAccumRedBits, ppfd->cAccumGreenBits,
           ppfd->cAccumBlueBits, ppfd->cAccumAlphaBits,
           0 /* ppfd->numSamples */, 0 /* ppfd->numMultisample */
           );
 }


 static void
 print_visual_info(HDC hdc, InfoMode mode)
 {
    PIXELFORMATDESCRIPTOR pfd;
    int numVisuals, numWglVisuals;
    int i;

    numVisuals = DescribePixelFormat(hdc, 1, sizeof(PIXELFORMATDESCRIPTOR), NULL);
    if (numVisuals == 0)
       return;

    numWglVisuals = 0;
    for (i = 0; i < numVisuals; i++) {
       if(!DescribePixelFormat(hdc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd))
 	 continue;

       //if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL))
       //   continue;

       ++numWglVisuals;
    }

    printf("%d WGL Visuals\n", numWglVisuals);

    if (mode == Normal)
       print_visual_attribs_short_header();
    else if (mode == Wide)
       print_visual_attribs_long_header();

    for (i = 0; i < numVisuals; i++) {
       if(!DescribePixelFormat(hdc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd))
 	 continue;

       //if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL))
       //   continue;

       if (mode == Verbose)
 	 print_visual_attribs_verbose(i, &pfd);
       else if (mode == Normal)
          print_visual_attribs_short(i, &pfd);
       else if (mode == Wide)
          print_visual_attribs_long(i, &pfd);
    }
    printf("\n");
 }


 /*
  * 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(HDC hdc)
 {
 #if 0
    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(hdc, mask, &theTemplate, &numVisuals);

    /* init bestVis with first visual info */
    get_visual_attribs(hdc, &visuals[0], &bestVis);

    /* try to find a "better" visual */
    for (i = 1; i < numVisuals; i++) {
       struct visual_attribs vis;

       get_visual_attribs(hdc, &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.iPixelType != vis.iPixelType) ||
           (!bestVis.doubleBuffer && vis.doubleBuffer) ||
           (bestVis.cRedBits < vis.cRedBits) ||
           (bestVis.cGreenBits < vis.cGreenBits) ||
           (bestVis.cBlueBits < vis.cBlueBits) ||
           (bestVis.cAlphaBits < vis.cAlphaBits) ||
           (bestVis.cDepthBits < vis.cDepthBits) ||
           (bestVis.cStencilBits < vis.cStencilBits) ||
           (bestVis.cAccumRedBits < vis.cAccumRedBits)) {
          /* found a better visual */
          bestVis = vis;
       }
    }

    return bestVis.id;
 #else
    return 0;
 #endif
 }


 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-h: This information.\n");
    printf("\t-b: Find the 'best' visual and print it's number.\n");
    printf("\t-l: Print interesting OpenGL limits.\n");
 }


 int
 main(int argc, char *argv[])
 {
    HDC hdc;
    InfoMode mode = Normal;
    GLboolean findBest = GL_FALSE;
    GLboolean limits = GL_FALSE;
    int i;

    for (i = 1; i < argc; i++) {
       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], "-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;
       }
    }

    hdc = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL);

    if (findBest) {
       int b;
       b = find_best_visual(hdc);
       printf("%d\n", b);
    }
    else {
       print_screen_info(hdc, limits);
       printf("\n");
       print_visual_info(hdc, mode);
    }

    return 0;
 }
	/*
	* Copyright (C) 2009 VMware, Inc.
	* 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
	* THE AUTHORS 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 GLX glxinfo program.
	* Command line options:
	* -t print wide table
	* -v print verbose information
	* -b only print ID of "best" visual on screen 0
	* -l print interesting OpenGL limits (added 5 Sep 2002)
	*/

	#include <windows.h>

	#include <GL/gl.h>
	#include <GL/glext.h>
	#include <GL/wglext.h>
	#include <stdio.h>
	#include <string.h>
	#include <stdlib.h>


	typedef enum
	{
	Normal,
	Wide,
	Verbose
	} InfoMode;


	/*
	* 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(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(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");
	}


	/**
	* 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 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" },
	{ 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)
	wglGetProcAddress("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; limits[i].token; i++) {
	GetProgramivARB_func(target, limits[i].token, max);
	if (glGetError() == GL_NO_ERROR) {
	printf(" %s = %d\n", 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]);
	}
	}

	#if defined(GL_EXT_convolution)
	{
	PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC glGetConvolutionParameterivEXT_func =
	(PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)wglGetProcAddress("glGetConvolutionParameterivEXT");
	if(glGetConvolutionParameterivEXT_func) {
	/* these don't fit into the above mechanism, unfortunately */
	glGetConvolutionParameterivEXT_func(GL_CONVOLUTION_2D, GL_MAX_CONVOLUTION_WIDTH, max);
	glGetConvolutionParameterivEXT_func(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]);
	}
	}
	}
	#endif

	#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 LRESULT CALLBACK
	WndProc(HWND hWnd,
	UINT uMsg,
	WPARAM wParam,
	LPARAM lParam )
	{
	switch (uMsg) {
	case WM_DESTROY:
	PostQuitMessage(0);
	break;
	default:
	return DefWindowProc(hWnd, uMsg, wParam, lParam);
	}

	return 0;
	}


	static void
	print_screen_info(HDC _hdc, GLboolean limits)
	{
	WNDCLASS wc;
	HWND win;
	HGLRC ctx;
	int visinfo;
	HDC hdc;
	PIXELFORMATDESCRIPTOR pfd;

	memset(&wc, 0, sizeof wc);
	wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
	wc.lpfnWndProc = WndProc;
	wc.lpszClassName = "wglinfo";
	wc.style = CS_OWNDC \| CS_HREDRAW \| CS_VREDRAW;
	RegisterClass(&wc);

	win = CreateWindowEx(0,
	wc.lpszClassName,
	"wglinfo",
	WS_CLIPSIBLINGS \| WS_CLIPCHILDREN,
	CW_USEDEFAULT,
	CW_USEDEFAULT,
	CW_USEDEFAULT,
	CW_USEDEFAULT,
	NULL,
	NULL,
	wc.hInstance,
	NULL);
	if (!win) {
	fprintf(stderr, "Couldn't create window");
	return;
	}

	hdc = GetDC(win);
	if (!hdc) {
	fprintf(stderr, "Couldn't obtain HDC");
	return;
	}

	pfd.cColorBits = 3;
	pfd.cRedBits = 1;
	pfd.cGreenBits = 1;
	pfd.cBlueBits = 1;
	pfd.dwFlags = PFD_DRAW_TO_WINDOW \| PFD_SUPPORT_OPENGL;
	pfd.iLayerType = PFD_MAIN_PLANE;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.nSize = sizeof(pfd);
	pfd.nVersion = 1;

	visinfo = ChoosePixelFormat(hdc, &pfd);
	if (!visinfo) {
	pfd.dwFlags \|= PFD_DOUBLEBUFFER;
	visinfo = ChoosePixelFormat(hdc, &pfd);
	}

	if (!visinfo) {
	fprintf(stderr, "Error: couldn't find RGB WGL visual\n");
	return;
	}

	SetPixelFormat(hdc, visinfo, &pfd);
	ctx = wglCreateContext(hdc);
	if (!ctx) {
	fprintf(stderr, "Error: wglCreateContext failed\n");
	return;
	}

	if (wglMakeCurrent(hdc, ctx)) {
	#if defined(WGL_ARB_extensions_string)
	PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB_func =
	(PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB");
	#endif
	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);

	#if defined(WGL_ARB_extensions_string)
	if(wglGetExtensionsStringARB_func) {
	const char *wglExtensions = wglGetExtensionsStringARB_func(hdc);
	if(wglExtensions) {
	printf("WGL extensions:\n");
	print_extension_list(wglExtensions);
	}
	}
	#endif
	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: wglMakeCurrent failed\n");
	}

	DestroyWindow(win);
	}


	static const char *
	visual_render_type_name(BYTE iPixelType)
	{
	switch (iPixelType) {
	case PFD_TYPE_RGBA:
	return "rgba";
	case PFD_TYPE_COLORINDEX:
	return "ci";
	default:
	return "";
	}
	}

	static void
	print_visual_attribs_verbose(int iPixelFormat, LPPIXELFORMATDESCRIPTOR ppfd)
	{
	printf("Visual ID: %x generic=%d native=%d\n",
	iPixelFormat,
	ppfd->dwFlags & PFD_GENERIC_FORMAT ? 1 : 0,
	ppfd->dwFlags & PFD_DRAW_TO_WINDOW ? 1 : 0);
	printf(" bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n",
	0 /* ppfd->bufferSize /, 0 / ppfd->level */,
	visual_render_type_name(ppfd->iPixelType),
	ppfd->dwFlags & PFD_DOUBLEBUFFER ? 1 : 0,
	ppfd->dwFlags & PFD_STEREO ? 1 : 0);
	printf(" rgba: cRedBits=%d cGreenBits=%d cBlueBits=%d cAlphaBits=%d\n",
	ppfd->cRedBits, ppfd->cGreenBits,
	ppfd->cBlueBits, ppfd->cAlphaBits);
	printf(" cAuxBuffers=%d cDepthBits=%d cStencilBits=%d\n",
	ppfd->cAuxBuffers, ppfd->cDepthBits, ppfd->cStencilBits);
	printf(" accum: cRedBits=%d cGreenBits=%d cBlueBits=%d cAlphaBits=%d\n",
	ppfd->cAccumRedBits, ppfd->cAccumGreenBits,
	ppfd->cAccumBlueBits, ppfd->cAccumAlphaBits);
	printf(" multiSample=%d multiSampleBuffers=%d\n",
	0 /* ppfd->numSamples /, 0 / ppfd->numMultisample */);
	}


	static void
	print_visual_attribs_short_header(void)
	{
	printf(" visual x bf lv rg d st colorbuffer ax dp st accumbuffer ms cav\n");
	printf(" id gen nat sp sz l ci b ro r g b a bf th cl r g b a ns b eat\n");
	printf("-----------------------------------------------------------------------\n");
	}


	static void
	print_visual_attribs_short(int iPixelFormat, LPPIXELFORMATDESCRIPTOR ppfd)
	{
	char *caveat = "None";

	printf("0x%02x %2d %2d %2d %2d %2d %c%c %c %c %2d %2d %2d %2d %2d %2d %2d",
	iPixelFormat,
	ppfd->dwFlags & PFD_GENERIC_FORMAT ? 1 : 0,
	ppfd->dwFlags & PFD_DRAW_TO_WINDOW ? 1 : 0,
	0,
	0 /* ppfd->bufferSize */,
	0 /* ppfd->level */,
	ppfd->iPixelType == PFD_TYPE_RGBA ? 'r' : ' ',
	ppfd->iPixelType == PFD_TYPE_COLORINDEX ? 'c' : ' ',
	ppfd->dwFlags & PFD_DOUBLEBUFFER ? 'y' : '.',
	ppfd->dwFlags & PFD_STEREO ? 'y' : '.',
	ppfd->cRedBits, ppfd->cGreenBits,
	ppfd->cBlueBits, ppfd->cAlphaBits,
	ppfd->cAuxBuffers,
	ppfd->cDepthBits,
	ppfd->cStencilBits
	);

	printf(" %2d %2d %2d %2d %2d %1d %s\n",
	ppfd->cAccumRedBits, ppfd->cAccumGreenBits,
	ppfd->cAccumBlueBits, ppfd->cAccumAlphaBits,
	0 /* ppfd->numSamples /, 0 / ppfd->numMultisample */,
	caveat
	);
	}


	static void
	print_visual_attribs_long_header(void)
	{
	printf("Vis Vis Visual Trans buff lev render DB ste r g b a aux dep ste accum buffers MS MS\n");
	printf(" ID Depth Type parent size el type reo sz sz sz sz buf th ncl r g b a num bufs\n");
	printf("----------------------------------------------------------------------------------------------------\n");
	}


	static void
	print_visual_attribs_long(int iPixelFormat, LPPIXELFORMATDESCRIPTOR ppfd)
	{
	printf("0x%2x %2d %11d %2d %2d %2d %4s %3d %3d %3d %3d %3d %3d",
	iPixelFormat,
	ppfd->dwFlags & PFD_GENERIC_FORMAT ? 1 : 0,
	ppfd->dwFlags & PFD_DRAW_TO_WINDOW ? 1 : 0,
	0,
	0 /* ppfd->bufferSize */,
	0 /* ppfd->level */,
	visual_render_type_name(ppfd->iPixelType),
	ppfd->dwFlags & PFD_DOUBLEBUFFER ? 1 : 0,
	ppfd->dwFlags & PFD_STEREO ? 1 : 0,
	ppfd->cRedBits, ppfd->cGreenBits,
	ppfd->cBlueBits, ppfd->cAlphaBits
	);

	printf(" %3d %4d %2d %3d %3d %3d %3d %2d %2d\n",
	ppfd->cAuxBuffers,
	ppfd->cDepthBits,
	ppfd->cStencilBits,
	ppfd->cAccumRedBits, ppfd->cAccumGreenBits,
	ppfd->cAccumBlueBits, ppfd->cAccumAlphaBits,
	0 /* ppfd->numSamples /, 0 / ppfd->numMultisample */
	);
	}


	static void
	print_visual_info(HDC hdc, InfoMode mode)
	{
	PIXELFORMATDESCRIPTOR pfd;
	int numVisuals, numWglVisuals;
	int i;

	numVisuals = DescribePixelFormat(hdc, 1, sizeof(PIXELFORMATDESCRIPTOR), NULL);
	if (numVisuals == 0)
	return;

	numWglVisuals = 0;
	for (i = 0; i < numVisuals; i++) {
	if(!DescribePixelFormat(hdc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd))
	continue;

	//if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL))
	// continue;

	++numWglVisuals;
	}

	printf("%d WGL Visuals\n", numWglVisuals);

	if (mode == Normal)
	print_visual_attribs_short_header();
	else if (mode == Wide)
	print_visual_attribs_long_header();

	for (i = 0; i < numVisuals; i++) {
	if(!DescribePixelFormat(hdc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd))
	continue;

	//if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL))
	// continue;

	if (mode == Verbose)
	print_visual_attribs_verbose(i, &pfd);
	else if (mode == Normal)
	print_visual_attribs_short(i, &pfd);
	else if (mode == Wide)
	print_visual_attribs_long(i, &pfd);
	}
	printf("\n");
	}


	/*
	* 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(HDC hdc)
	{
	#if 0
	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(hdc, mask, &theTemplate, &numVisuals);

	/* init bestVis with first visual info */
	get_visual_attribs(hdc, &visuals[0], &bestVis);

	/* try to find a "better" visual */
	for (i = 1; i < numVisuals; i++) {
	struct visual_attribs vis;

	get_visual_attribs(hdc, &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.iPixelType != vis.iPixelType) \|\|
	(!bestVis.doubleBuffer && vis.doubleBuffer) \|\|
	(bestVis.cRedBits < vis.cRedBits) \|\|
	(bestVis.cGreenBits < vis.cGreenBits) \|\|
	(bestVis.cBlueBits < vis.cBlueBits) \|\|
	(bestVis.cAlphaBits < vis.cAlphaBits) \|\|
	(bestVis.cDepthBits < vis.cDepthBits) \|\|
	(bestVis.cStencilBits < vis.cStencilBits) \|\|
	(bestVis.cAccumRedBits < vis.cAccumRedBits)) {
	/* found a better visual */
	bestVis = vis;
	}
	}

	return bestVis.id;
	#else
	return 0;
	#endif
	}


	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-h: This information.\n");
	printf("\t-b: Find the 'best' visual and print it's number.\n");
	printf("\t-l: Print interesting OpenGL limits.\n");
	}


	int
	main(int argc, char *argv[])
	{
	HDC hdc;
	InfoMode mode = Normal;
	GLboolean findBest = GL_FALSE;
	GLboolean limits = GL_FALSE;
	int i;

	for (i = 1; i < argc; i++) {
	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], "-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;
	}
	}

	hdc = CreateDC(TEXT("DISPLAY"), NULL, NULL, NULL);

	if (findBest) {
	int b;
	b = find_best_visual(hdc);
	printf("%d\n", b);
	}
	else {
	print_screen_info(hdc, limits);
	printf("\n");
	print_visual_info(hdc, mode);
	}

	return 0;
	}