psychlops/platform/win32gl/extension/glew/visualinfo.c

   1 /*\r
   2 ** visualinfo.c\r
   3 **\r
   4 ** Copyright (C) Nate Robins, 1997\r
   5 **               Michael Wimmer, 1999\r
   6 **               Milan Ikits, 2002-2008\r
   7 **\r
   8 ** visualinfo is a small utility that displays all available visuals,\r
   9 ** aka. pixelformats, in an OpenGL system along with renderer version\r
  10 ** information. It shows a table of all the visuals that support OpenGL\r
  11 ** along with their capabilities. The format of the table is similar to\r
  12 ** that of glxinfo on Unix systems:\r
  13 **\r
  14 ** visual ~= pixel format descriptor\r
  15 ** id       = visual id (integer from 1 - max visuals)\r
  16 ** tp       = type (wn: window, pb: pbuffer, wp: window & pbuffer, bm: bitmap)\r
  17 ** ac       = acceleration (ge: generic, fu: full, no: none)\r
  18 ** fm       = format (i: integer, f: float, c: color index)\r
  19 ** db       = double buffer (y = yes)\r
  20 ** sw       = swap method (x: exchange, c: copy, u: undefined)\r
  21 ** st       = stereo (y = yes)\r
  22 ** sz       = total # bits\r
  23 ** r        = # bits of red\r
  24 ** g        = # bits of green\r
  25 ** b        = # bits of blue\r
  26 ** a        = # bits of alpha\r
  27 ** axbf     = # aux buffers\r
  28 ** dpth     = # bits of depth\r
  29 ** stcl     = # bits of stencil\r
  30 */\r
  31 \r
  32 #include <stdio.h>\r
  33 #include <stdlib.h>\r
  34 #include <string.h>\r
  35 #include <GL/glew.h>\r
  36 #if defined(_WIN32)\r
  37 #include <GL/wglew.h>\r
  38 #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)\r
  39 #include <AGL/agl.h>\r
  40 #else\r
  41 #include <GL/glxew.h>\r
  42 #endif\r
  43 \r
  44 #ifdef GLEW_MX\r
  45 GLEWContext _glewctx;\r
  46 #  define glewGetContext() (&_glewctx)\r
  47 #  ifdef _WIN32\r
  48 WGLEWContext _wglewctx;\r
  49 #    define wglewGetContext() (&_wglewctx)\r
  50 #  elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)\r
  51 GLXEWContext _glxewctx;\r
  52 #    define glxewGetContext() (&_glxewctx)\r
  53 #  endif\r
  54 #endif /* GLEW_MX */\r
  55 \r
  56 typedef struct GLContextStruct\r
  57 {\r
  58 #ifdef _WIN32\r
  59   HWND wnd;\r
  60   HDC dc;\r
  61   HGLRC rc;\r
  62 #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)\r
  63   AGLContext ctx, octx;\r
  64 #else\r
  65   Display* dpy;\r
  66   XVisualInfo* vi;\r
  67   GLXContext ctx;\r
  68   Window wnd;\r
  69   Colormap cmap;\r
  70 #endif\r
  71 } GLContext;\r
  72 \r
  73 void InitContext (GLContext* ctx);\r
  74 GLboolean CreateContext (GLContext* ctx);\r
  75 void DestroyContext (GLContext* ctx);\r
  76 void VisualInfo (GLContext* ctx);\r
  77 void PrintExtensions (const char* s);\r
  78 GLboolean ParseArgs (int argc, char** argv);\r
  79 \r
  80 int showall = 0;\r
  81 int displaystdout = 0;\r
  82 int verbose = 0;\r
  83 int drawableonly = 0;\r
  84 \r
  85 char* display = NULL;\r
  86 int visual = -1;\r
  87 \r
  88 FILE* file = 0;\r
  89 GLContext ctx;\r
  90 \r
  91 int \r
  92 main (int argc, char** argv)\r
  93 {\r
  94   GLenum err;\r
  95 \r
  96   /* ---------------------------------------------------------------------- */\r
  97   /* parse arguments */\r
  98   if (GL_TRUE == ParseArgs(argc-1, argv+1))\r
  99   {\r
 100 #if defined(_WIN32)\r
 101     fprintf(stderr, "Usage: visualinfo [-a] [-s] [-h] [-pf <id>]\n");\r
 102     fprintf(stderr, "        -a: show all visuals\n");\r
 103     fprintf(stderr, "        -s: display to stdout instead of visualinfo.txt\n");\r
 104     fprintf(stderr, "        -pf <id>: use given pixelformat\n");\r
 105     fprintf(stderr, "        -h: this screen\n");\r
 106 #else\r
 107     fprintf(stderr, "Usage: visualinfo [-h] [-display <display>] [-visual <id>]\n");\r
 108     fprintf(stderr, "        -h: this screen\n");\r
 109     fprintf(stderr, "        -display <display>: use given display\n");\r
 110     fprintf(stderr, "        -visual <id>: use given visual\n");\r
 111 #endif\r
 112     return 1;\r
 113   }\r
 114 \r
 115   /* ---------------------------------------------------------------------- */\r
 116   /* create OpenGL rendering context */\r
 117   InitContext(&ctx);\r
 118   if (GL_TRUE == CreateContext(&ctx))\r
 119   {\r
 120     fprintf(stderr, "Error: CreateContext failed\n");\r
 121     DestroyContext(&ctx);\r
 122     return 1;\r
 123   }\r
 124 \r
 125   /* ---------------------------------------------------------------------- */\r
 126   /* initialize GLEW */\r
 127   glewExperimental = GL_TRUE;\r
 128 #ifdef GLEW_MX\r
 129   err = glewContextInit(glewGetContext());\r
 130 #  ifdef _WIN32\r
 131   err = err || wglewContextInit(wglewGetContext());\r
 132 #  elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX)\r
 133   err = err || glxewContextInit(glxewGetContext());\r
 134 #  endif\r
 135 #else\r
 136   err = glewInit();\r
 137 #endif\r
 138   if (GLEW_OK != err)\r
 139   {\r
 140     fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));\r
 141     DestroyContext(&ctx);\r
 142     return 1;\r
 143   }\r
 144 \r
 145   /* ---------------------------------------------------------------------- */\r
 146   /* open file */\r
 147 #if defined(_WIN32)\r
 148   if (!displaystdout) \r
 149     file = fopen("visualinfo.txt", "w");\r
 150   if (file == NULL)\r
 151     file = stdout;\r
 152 #else\r
 153   file = stdout;\r
 154 #endif\r
 155 \r
 156   /* ---------------------------------------------------------------------- */\r
 157   /* output header information */\r
 158   /* OpenGL extensions */\r
 159   fprintf(file, "OpenGL vendor string: %s\n", glGetString(GL_VENDOR));\r
 160   fprintf(file, "OpenGL renderer string: %s\n", glGetString(GL_RENDERER));\r
 161   fprintf(file, "OpenGL version string: %s\n", glGetString(GL_VERSION));\r
 162   fprintf(file, "OpenGL extensions (GL_): \n");\r
 163   PrintExtensions((char*)glGetString(GL_EXTENSIONS));\r
 164   /* GLU extensions */\r
 165   fprintf(file, "GLU version string: %s\n", gluGetString(GLU_VERSION));\r
 166   fprintf(file, "GLU extensions (GLU_): \n");\r
 167   PrintExtensions((char*)gluGetString(GLU_EXTENSIONS));\r
 168 \r
 169   /* ---------------------------------------------------------------------- */\r
 170   /* extensions string */\r
 171 #if defined(_WIN32)\r
 172   /* WGL extensions */\r
 173   if (WGLEW_ARB_extensions_string || WGLEW_EXT_extensions_string)\r
 174   {\r
 175     fprintf(file, "WGL extensions (WGL_): \n");\r
 176     PrintExtensions(wglGetExtensionsStringARB ? \r
 177                     (char*)wglGetExtensionsStringARB(ctx.dc) :\r
 178                     (char*)wglGetExtensionsStringEXT());\r
 179   }\r
 180 #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)\r
 181   \r
 182 #else\r
 183   /* GLX extensions */\r
 184   fprintf(file, "GLX extensions (GLX_): \n");\r
 185   PrintExtensions(glXQueryExtensionsString(glXGetCurrentDisplay(), \r
 186                                            DefaultScreen(glXGetCurrentDisplay())));\r
 187 #endif\r
 188 \r
 189   /* ---------------------------------------------------------------------- */\r
 190   /* enumerate all the formats */\r
 191   VisualInfo(&ctx);\r
 192 \r
 193   /* ---------------------------------------------------------------------- */\r
 194   /* release resources */\r
 195   DestroyContext(&ctx);\r
 196   if (file != stdout)\r
 197     fclose(file);\r
 198   return 0;\r
 199 }\r
 200 \r
 201 /* do the magic to separate all extensions with comma's, except\r
 202    for the last one that _may_ terminate in a space. */\r
 203 void PrintExtensions (const char* s)\r
 204 {\r
 205   char t[80];\r
 206   int i=0;\r
 207   char* p=0;\r
 208 \r
 209   t[79] = '\0';\r
 210   while (*s)\r
 211   {\r
 212     t[i++] = *s;\r
 213     if(*s == ' ')\r
 214     {\r
 215       if (*(s+1) != '\0') {\r
 216         t[i-1] = ',';\r
 217         t[i] = ' ';\r
 218         p = &t[i++];\r
 219       }\r
 220       else /* zoinks! last one terminated in a space! */\r
 221       {\r
 222         t[i-1] = '\0';\r
 223       }\r
 224     }\r
 225     if(i > 80 - 5)\r
 226     {\r
 227       *p = t[i] = '\0';\r
 228       fprintf(file, "    %s\n", t);\r
 229       p++;\r
 230       i = (int)strlen(p);\r
 231       strcpy(t, p);\r
 232     }\r
 233     s++;\r
 234   }\r
 235   t[i] = '\0';\r
 236   fprintf(file, "    %s.\n", t);\r
 237 }\r
 238 \r
 239 /* ---------------------------------------------------------------------- */\r
 240 \r
 241 #if defined(_WIN32)\r
 242 \r
 243 void\r
 244 VisualInfoARB (GLContext* ctx)\r
 245 {\r
 246   int attrib[32], value[32], n_attrib, n_pbuffer=0, n_float=0;\r
 247   int i, pf, maxpf;\r
 248   unsigned int c;\r
 249 \r
 250   /* to get pbuffer capable pixel formats */\r
 251   attrib[0] = WGL_DRAW_TO_PBUFFER_ARB;\r
 252   attrib[1] = GL_TRUE;\r
 253   attrib[2] = 0;\r
 254   wglChoosePixelFormatARB(ctx->dc, attrib, 0, 1, &pf, &c);\r
 255   /* query number of pixel formats */\r
 256   attrib[0] = WGL_NUMBER_PIXEL_FORMATS_ARB;\r
 257   wglGetPixelFormatAttribivARB(ctx->dc, 0, 0, 1, attrib, value);\r
 258   maxpf = value[0];\r
 259   for (i=0; i<32; i++)\r
 260     value[i] = 0;\r
 261 \r
 262   attrib[0] = WGL_SUPPORT_OPENGL_ARB;\r
 263   attrib[1] = WGL_DRAW_TO_WINDOW_ARB;\r
 264   attrib[2] = WGL_DRAW_TO_BITMAP_ARB;\r
 265   attrib[3] = WGL_ACCELERATION_ARB;\r
 266   /* WGL_NO_ACCELERATION_ARB, WGL_GENERIC_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB */\r
 267   attrib[4] = WGL_SWAP_METHOD_ARB;\r
 268   /* WGL_SWAP_EXCHANGE_ARB, WGL_SWAP_COPY_ARB, WGL_SWAP_UNDEFINED_ARB */\r
 269   attrib[5] = WGL_DOUBLE_BUFFER_ARB;\r
 270   attrib[6] = WGL_STEREO_ARB;\r
 271   attrib[7] = WGL_PIXEL_TYPE_ARB;\r
 272   /* WGL_TYPE_RGBA_ARB, WGL_TYPE_COLORINDEX_ARB,\r
 273      WGL_TYPE_RGBA_FLOAT_ATI (WGL_ATI_pixel_format_float) */\r
 274   /* Color buffer information */\r
 275   attrib[8] = WGL_COLOR_BITS_ARB;\r
 276   attrib[9] = WGL_RED_BITS_ARB;\r
 277   attrib[10] = WGL_GREEN_BITS_ARB;\r
 278   attrib[11] = WGL_BLUE_BITS_ARB;\r
 279   attrib[12] = WGL_ALPHA_BITS_ARB;\r
 280   /* Accumulation buffer information */\r
 281   attrib[13] = WGL_ACCUM_BITS_ARB;\r
 282   attrib[14] = WGL_ACCUM_RED_BITS_ARB;\r
 283   attrib[15] = WGL_ACCUM_GREEN_BITS_ARB;\r
 284   attrib[16] = WGL_ACCUM_BLUE_BITS_ARB;\r
 285   attrib[17] = WGL_ACCUM_ALPHA_BITS_ARB;\r
 286   /* Depth, stencil, and aux buffer information */\r
 287   attrib[18] = WGL_DEPTH_BITS_ARB;\r
 288   attrib[19] = WGL_STENCIL_BITS_ARB;\r
 289   attrib[20] = WGL_AUX_BUFFERS_ARB;\r
 290   /* Layer information */\r
 291   attrib[21] = WGL_NUMBER_OVERLAYS_ARB;\r
 292   attrib[22] = WGL_NUMBER_UNDERLAYS_ARB;\r
 293   attrib[23] = WGL_SWAP_LAYER_BUFFERS_ARB;\r
 294   attrib[24] = WGL_SAMPLES_ARB;\r
 295   attrib[25] = WGL_SUPPORT_GDI_ARB;\r
 296   n_attrib = 26;\r
 297   if (WGLEW_ARB_pbuffer)\r
 298   {\r
 299     attrib[n_attrib] = WGL_DRAW_TO_PBUFFER_ARB;\r
 300     n_pbuffer = n_attrib;\r
 301     n_attrib++;\r
 302   }\r
 303   if (WGLEW_NV_float_buffer)\r
 304   {\r
 305     attrib[n_attrib] = WGL_FLOAT_COMPONENTS_NV;\r
 306     n_float = n_attrib;\r
 307     n_attrib++;\r
 308   }\r
 309   \r
 310   if (!verbose)\r
 311   {\r
 312     /* print table header */\r
 313     fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");\r
 314     fprintf(file, " |     |          visual         |      color      | ax dp st |      accum      |   layer  |\n");\r
 315     fprintf(file, " |  id | tp ac gd fm db sw st ms |  sz  r  g  b  a | bf th cl |  sz  r  g  b  a | ov un sw |\n");\r
 316     fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");\r
 317     /* loop through all the pixel formats */\r
 318     for(i = 1; i <= maxpf; i++)\r
 319     {\r
 320       wglGetPixelFormatAttribivARB(ctx->dc, i, 0, n_attrib, attrib, value);\r
 321       /* only describe this format if it supports OpenGL */\r
 322       if (!value[0]) continue;\r
 323       /* by default show only fully accelerated window or pbuffer capable visuals */\r
 324       if (!showall\r
 325           && ((value[2] && !value[1])\r
 326           || (!WGLEW_ARB_pbuffer || !value[n_pbuffer])\r
 327           || (value[3] != WGL_FULL_ACCELERATION_ARB))) continue;\r
 328       /* print out the information for this visual */\r
 329       /* visual id */\r
 330       fprintf(file, " |% 4d | ", i);\r
 331       /* visual type */\r
 332       if (value[1])\r
 333       {\r
 334         if (WGLEW_ARB_pbuffer && value[n_pbuffer]) fprintf(file, "wp ");\r
 335         else fprintf(file, "wn ");\r
 336       }\r
 337       else\r
 338       {\r
 339         if (value[2]) fprintf(file, "bm ");\r
 340         else if (WGLEW_ARB_pbuffer && value[n_pbuffer]) fprintf(file, "pb ");\r
 341       }\r
 342       /* acceleration */\r
 343       fprintf(file, "%s ", value[3] == WGL_FULL_ACCELERATION_ARB ? "fu" : \r
 344               value[3] == WGL_GENERIC_ACCELERATION_ARB ? "ge" :\r
 345               value[3] == WGL_NO_ACCELERATION_ARB ? "no" : ". ");\r
 346       /* gdi support */\r
 347       fprintf(file, " %c ", value[25] ? 'y' : '.');\r
 348       /* format */\r
 349       if (WGLEW_NV_float_buffer && value[n_float]) fprintf(file, " f ");\r
 350       else if (WGLEW_ATI_pixel_format_float && value[7] == WGL_TYPE_RGBA_FLOAT_ATI) fprintf(file, " f ");\r
 351       else if (value[7] == WGL_TYPE_RGBA_ARB) fprintf(file, " i ");\r
 352       else if (value[7] == WGL_TYPE_COLORINDEX_ARB) fprintf(file, " c ");\r
 353       /* double buffer */\r
 354       fprintf(file, " %c ", value[5] ? 'y' : '.');\r
 355       /* swap method */\r
 356       if (value[4] == WGL_SWAP_EXCHANGE_ARB) fprintf(file, " x ");\r
 357       else if (value[4] == WGL_SWAP_COPY_ARB) fprintf(file, " c ");\r
 358       else if (value[4] == WGL_SWAP_UNDEFINED_ARB) fprintf(file, " . ");\r
 359       else fprintf(file, " . ");\r
 360       /* stereo */\r
 361       fprintf(file, " %c ", value[6] ? 'y' : '.');\r
 362       /* multisample */\r
 363       if (value[24] > 0)\r
 364         fprintf(file, "%2d | ", value[24]);\r
 365       else\r
 366         fprintf(file, " . | ");\r
 367       /* color size */\r
 368       if (value[8]) fprintf(file, "%3d ", value[8]);\r
 369       else fprintf(file, "  . ");\r
 370       /* red */\r
 371       if (value[9]) fprintf(file, "%2d ", value[9]); \r
 372       else fprintf(file, " . ");\r
 373       /* green */\r
 374       if (value[10]) fprintf(file, "%2d ", value[10]); \r
 375       else fprintf(file, " . ");\r
 376       /* blue */\r
 377       if (value[11]) fprintf(file, "%2d ", value[11]);\r
 378       else fprintf(file, " . ");\r
 379       /* alpha */\r
 380       if (value[12]) fprintf(file, "%2d | ", value[12]); \r
 381       else fprintf(file, " . | ");\r
 382       /* aux buffers */\r
 383       if (value[20]) fprintf(file, "%2d ", value[20]);\r
 384       else fprintf(file, " . ");\r
 385       /* depth */\r
 386       if (value[18]) fprintf(file, "%2d ", value[18]);\r
 387       else fprintf(file, " . ");\r
 388       /* stencil */\r
 389       if (value[19]) fprintf(file, "%2d | ", value[19]);\r
 390       else fprintf(file, " . | ");\r
 391       /* accum size */\r
 392       if (value[13]) fprintf(file, "%3d ", value[13]);\r
 393       else fprintf(file, "  . ");\r
 394       /* accum red */\r
 395       if (value[14]) fprintf(file, "%2d ", value[14]);\r
 396       else fprintf(file, " . ");\r
 397       /* accum green */\r
 398       if (value[15]) fprintf(file, "%2d ", value[15]);\r
 399       else fprintf(file, " . ");\r
 400       /* accum blue */\r
 401       if (value[16]) fprintf(file, "%2d ", value[16]);\r
 402       else fprintf(file, " . ");\r
 403       /* accum alpha */\r
 404       if (value[17]) fprintf(file, "%2d | ", value[17]);\r
 405       else fprintf(file, " . | ");\r
 406       /* overlay */\r
 407       if (value[21]) fprintf(file, "%2d ", value[21]);\r
 408       else fprintf(file, " . ");\r
 409       /* underlay */\r
 410       if (value[22]) fprintf(file, "%2d ", value[22]);\r
 411       else fprintf(file, " . ");\r
 412       /* layer swap */\r
 413       if (value[23]) fprintf(file, "y ");\r
 414       else fprintf(file, " . ");\r
 415       fprintf(file, "|\n");\r
 416     }\r
 417     /* print table footer */\r
 418     fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");\r
 419     fprintf(file, " |     |          visual         |      color      | ax dp st |      accum      |   layer  |\n");\r
 420     fprintf(file, " |  id | tp ac gd fm db sw st ms |  sz  r  g  b  a | bf th cl |  sz  r  g  b  a | ov un sw |\n");\r
 421     fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");\r
 422   }\r
 423   else /* verbose */\r
 424   {\r
 425 #if 0\r
 426     fprintf(file, "\n");\r
 427     /* loop through all the pixel formats */\r
 428     for(i = 1; i <= maxpf; i++)\r
 429     {       \r
 430       DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);\r
 431       /* only describe this format if it supports OpenGL */\r
 432       if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)\r
 433          || (drawableonly && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))) continue;\r
 434       fprintf(file, "Visual ID: %2d  depth=%d  class=%s\n", i, pfd.cDepthBits, \r
 435              pfd.cColorBits <= 8 ? "PseudoColor" : "TrueColor");\r
 436       fprintf(file, "    bufferSize=%d level=%d renderType=%s doubleBuffer=%d stereo=%d\n", pfd.cColorBits, pfd.bReserved, pfd.iPixelType == PFD_TYPE_RGBA ? "rgba" : "ci", pfd.dwFlags & PFD_DOUBLEBUFFER, pfd.dwFlags & PFD_STEREO);\r
 437       fprintf(file, "    generic=%d generic accelerated=%d\n", (pfd.dwFlags & PFD_GENERIC_FORMAT) == PFD_GENERIC_FORMAT, (pfd.dwFlags & PFD_GENERIC_ACCELERATED) == PFD_GENERIC_ACCELERATED);\r
 438       fprintf(file, "    rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cRedBits, pfd.cGreenBits, pfd.cBlueBits, pfd.cAlphaBits);\r
 439       fprintf(file, "    auxBuffers=%d depthSize=%d stencilSize=%d\n", pfd.cAuxBuffers, pfd.cDepthBits, pfd.cStencilBits);\r
 440       fprintf(file, "    accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cAccumRedBits, pfd.cAccumGreenBits, pfd.cAccumBlueBits, pfd.cAccumAlphaBits);\r
 441       fprintf(file, "    multiSample=%d multisampleBuffers=%d\n", 0, 0);\r
 442       fprintf(file, "    Opaque.\n");\r
 443     }\r
 444 #endif\r
 445   }\r
 446 }\r
 447 \r
 448 void\r
 449 VisualInfoGDI (GLContext* ctx)\r
 450 {\r
 451   int i, maxpf;\r
 452   PIXELFORMATDESCRIPTOR pfd;\r
 453 \r
 454   /* calling DescribePixelFormat() with NULL pfd (!!!) return maximum\r
 455      number of pixel formats */\r
 456   maxpf = DescribePixelFormat(ctx->dc, 1, 0, NULL);\r
 457 \r
 458   if (!verbose)\r
 459   {\r
 460     fprintf(file, "-----------------------------------------------------------------------------\n");\r
 461     fprintf(file, "   visual   x  bf  lv rg d st ge ge  r  g  b a  ax dp st   accum buffs    ms \n");\r
 462     fprintf(file, " id  dep tp sp sz  l  ci b ro ne ac sz sz sz sz bf th cl  sz  r  g  b  a ns b\n");\r
 463     fprintf(file, "-----------------------------------------------------------------------------\n");\r
 464 \r
 465     /* loop through all the pixel formats */\r
 466     for(i = 1; i <= maxpf; i++)\r
 467     {\r
 468       DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);\r
 469       /* only describe this format if it supports OpenGL */\r
 470       if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)\r
 471          || (drawableonly && (pfd.dwFlags & PFD_DRAW_TO_BITMAP))) continue;\r
 472       /* other criteria could be tested here for actual pixel format\r
 473          choosing in an application:\r
 474            \r
 475          for (...each pixel format...) {\r
 476          if (pfd.dwFlags & PFD_SUPPORT_OPENGL &&\r
 477          pfd.dwFlags & PFD_DOUBLEBUFFER &&\r
 478          pfd.cDepthBits >= 24 &&\r
 479          pfd.cColorBits >= 24)\r
 480          {\r
 481          goto found;\r
 482          }\r
 483          }\r
 484          ... not found so exit ...\r
 485          found:\r
 486          ... found so use it ...\r
 487       */\r
 488       /* print out the information for this pixel format */\r
 489       fprintf(file, "0x%02x ", i);\r
 490       fprintf(file, "%3d ", pfd.cColorBits);\r
 491       if(pfd.dwFlags & PFD_DRAW_TO_WINDOW) fprintf(file, "wn ");\r
 492       else if(pfd.dwFlags & PFD_DRAW_TO_BITMAP) fprintf(file, "bm ");\r
 493       else fprintf(file, "pb ");\r
 494       /* should find transparent pixel from LAYERPLANEDESCRIPTOR */\r
 495       fprintf(file, " . "); \r
 496       fprintf(file, "%3d ", pfd.cColorBits);\r
 497       /* bReserved field indicates number of over/underlays */\r
 498       if(pfd.bReserved) fprintf(file, " %d ", pfd.bReserved);\r
 499       else fprintf(file, " . "); \r
 500       fprintf(file, " %c ", pfd.iPixelType == PFD_TYPE_RGBA ? 'r' : 'c');\r
 501       fprintf(file, "%c ", pfd.dwFlags & PFD_DOUBLEBUFFER ? 'y' : '.');\r
 502       fprintf(file, " %c ", pfd.dwFlags & PFD_STEREO ? 'y' : '.');\r
 503       /* added: */\r
 504       fprintf(file, " %c ", pfd.dwFlags & PFD_GENERIC_FORMAT ? 'y' : '.');\r
 505       fprintf(file, " %c ", pfd.dwFlags & PFD_GENERIC_ACCELERATED ? 'y' : '.');\r
 506       if(pfd.cRedBits && pfd.iPixelType == PFD_TYPE_RGBA) \r
 507         fprintf(file, "%2d ", pfd.cRedBits);\r
 508       else fprintf(file, " . ");\r
 509       if(pfd.cGreenBits && pfd.iPixelType == PFD_TYPE_RGBA) \r
 510         fprintf(file, "%2d ", pfd.cGreenBits);\r
 511       else fprintf(file, " . ");\r
 512       if(pfd.cBlueBits && pfd.iPixelType == PFD_TYPE_RGBA) \r
 513         fprintf(file, "%2d ", pfd.cBlueBits);\r
 514       else fprintf(file, " . ");\r
 515       if(pfd.cAlphaBits && pfd.iPixelType == PFD_TYPE_RGBA) \r
 516         fprintf(file, "%2d ", pfd.cAlphaBits);\r
 517       else fprintf(file, " . ");\r
 518       if(pfd.cAuxBuffers)     fprintf(file, "%2d ", pfd.cAuxBuffers);\r
 519       else fprintf(file, " . ");\r
 520       if(pfd.cDepthBits)      fprintf(file, "%2d ", pfd.cDepthBits);\r
 521       else fprintf(file, " . ");\r
 522       if(pfd.cStencilBits)    fprintf(file, "%2d ", pfd.cStencilBits);\r
 523       else fprintf(file, " . ");\r
 524       if(pfd.cAccumBits)   fprintf(file, "%3d ", pfd.cAccumBits);\r
 525       else fprintf(file, "  . ");\r
 526       if(pfd.cAccumRedBits)   fprintf(file, "%2d ", pfd.cAccumRedBits);\r
 527       else fprintf(file, " . ");\r
 528       if(pfd.cAccumGreenBits) fprintf(file, "%2d ", pfd.cAccumGreenBits);\r
 529       else fprintf(file, " . ");\r
 530       if(pfd.cAccumBlueBits)  fprintf(file, "%2d ", pfd.cAccumBlueBits);\r
 531       else fprintf(file, " . ");\r
 532       if(pfd.cAccumAlphaBits) fprintf(file, "%2d ", pfd.cAccumAlphaBits);\r
 533       else fprintf(file, " . ");\r
 534       /* no multisample in win32 */\r
 535       fprintf(file, " . .\n");\r
 536     }\r
 537     /* print table footer */\r
 538     fprintf(file, "-----------------------------------------------------------------------------\n");\r
 539     fprintf(file, "   visual   x  bf  lv rg d st ge ge  r  g  b a  ax dp st   accum buffs    ms \n");\r
 540     fprintf(file, " id  dep tp sp sz  l  ci b ro ne ac sz sz sz sz bf th cl  sz  r  g  b  a ns b\n");\r
 541     fprintf(file, "-----------------------------------------------------------------------------\n");\r
 542   }\r
 543   else /* verbose */\r
 544   {\r
 545     fprintf(file, "\n");\r
 546     /* loop through all the pixel formats */\r
 547     for(i = 1; i <= maxpf; i++)\r
 548     {       \r
 549       DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);\r
 550       /* only describe this format if it supports OpenGL */\r
 551       if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)\r
 552          || (drawableonly && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))) continue;\r
 553       fprintf(file, "Visual ID: %2d  depth=%d  class=%s\n", i, pfd.cDepthBits, \r
 554              pfd.cColorBits <= 8 ? "PseudoColor" : "TrueColor");\r
 555       fprintf(file, "    bufferSize=%d level=%d renderType=%s doubleBuffer=%ld stereo=%ld\n", pfd.cColorBits, pfd.bReserved, pfd.iPixelType == PFD_TYPE_RGBA ? "rgba" : "ci", pfd.dwFlags & PFD_DOUBLEBUFFER, pfd.dwFlags & PFD_STEREO);\r
 556       fprintf(file, "    generic=%d generic accelerated=%d\n", (pfd.dwFlags & PFD_GENERIC_FORMAT) == PFD_GENERIC_FORMAT, (pfd.dwFlags & PFD_GENERIC_ACCELERATED) == PFD_GENERIC_ACCELERATED);\r
 557       fprintf(file, "    rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cRedBits, pfd.cGreenBits, pfd.cBlueBits, pfd.cAlphaBits);\r
 558       fprintf(file, "    auxBuffers=%d depthSize=%d stencilSize=%d\n", pfd.cAuxBuffers, pfd.cDepthBits, pfd.cStencilBits);\r
 559       fprintf(file, "    accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cAccumRedBits, pfd.cAccumGreenBits, pfd.cAccumBlueBits, pfd.cAccumAlphaBits);\r
 560       fprintf(file, "    multiSample=%d multisampleBuffers=%d\n", 0, 0);\r
 561       fprintf(file, "    Opaque.\n");\r
 562     }\r
 563   }\r
 564 }\r
 565 \r
 566 void\r
 567 VisualInfo (GLContext* ctx)\r
 568 {\r
 569   if (WGLEW_ARB_pixel_format)\r
 570     VisualInfoARB(ctx);\r
 571   else\r
 572     VisualInfoGDI(ctx);\r
 573 }\r
 574 \r
 575 /* ---------------------------------------------------------------------- */\r
 576 \r
 577 #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)\r
 578 \r
 579 void\r
 580 VisualInfo (GLContext* ctx)\r
 581 {\r
 582 /*\r
 583   int attrib[] = { AGL_RGBA, AGL_NONE };\r
 584   AGLPixelFormat pf;\r
 585   GLint value;\r
 586   pf = aglChoosePixelFormat(NULL, 0, attrib);\r
 587   while (pf != NULL)\r
 588   {\r
 589     aglDescribePixelFormat(pf, GL_RGBA, &value);\r
 590     fprintf(stderr, "%d\n", value);\r
 591     pf = aglNextPixelFormat(pf);\r
 592   }\r
 593 */\r
 594 }\r
 595 \r
 596 #else /* GLX */\r
 597 \r
 598 void\r
 599 VisualInfo (GLContext* ctx)\r
 600 {\r
 601   int n_fbc;\r
 602   GLXFBConfig* fbc;\r
 603   int value, ret, i;\r
 604 \r
 605   fbc = glXGetFBConfigs(ctx->dpy, DefaultScreen(ctx->dpy), &n_fbc);\r
 606 \r
 607   if (fbc)\r
 608   {\r
 609     if (!verbose)\r
 610     {\r
 611       /* print table header */\r
 612       fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");\r
 613       fprintf(file, " |     |        visual           |      color      | ax dp st |    accum    |   ms  |  cav |\n");\r
 614       fprintf(file, " |  id | tp xr cl fm db st lv xp |  sz  r  g  b  a | bf th cl | r  g  b  a  | ns  b |  eat |\n");\r
 615       fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");\r
 616       /* loop through all the fbcs */\r
 617       for (i=0; i<n_fbc; i++)\r
 618       {\r
 619         /* print out the information for this fbc */\r
 620         /* visual id */\r
 621         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_FBCONFIG_ID, &value);\r
 622         if (ret != Success)\r
 623         {\r
 624           fprintf(file, "|  ?  |");\r
 625         }\r
 626         else\r
 627         {\r
 628           fprintf(file, " |% 4d | ", value);\r
 629         }\r
 630         /* visual type */\r
 631         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DRAWABLE_TYPE, &value);\r
 632         if (ret != Success)\r
 633         {\r
 634           fprintf(file, " ? ");\r
 635         }\r
 636         else\r
 637         {\r
 638           if (value & GLX_WINDOW_BIT)\r
 639           {\r
 640             if (value & GLX_PBUFFER_BIT)\r
 641             {\r
 642               fprintf(file, "wp ");\r
 643             }\r
 644             else\r
 645             {\r
 646               fprintf(file, "wn ");\r
 647             }\r
 648           }\r
 649           else\r
 650           {\r
 651             if (value & GLX_PBUFFER_BIT)\r
 652             {\r
 653               fprintf(file, "pb ");\r
 654             }\r
 655             else if (value & GLX_PIXMAP_BIT)\r
 656             {\r
 657               fprintf(file, "pm ");\r
 658             }\r
 659             else\r
 660             {\r
 661               fprintf(file, " ? ");\r
 662             }\r
 663           }\r
 664         }\r
 665         /* x renderable */\r
 666         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_X_RENDERABLE, &value);\r
 667         if (ret != Success)\r
 668         {\r
 669           fprintf(file, " ? ");\r
 670         }\r
 671         else\r
 672         {\r
 673           fprintf(file, value ? " y " : " n ");\r
 674         }\r
 675         /* class */\r
 676         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_X_VISUAL_TYPE, &value);\r
 677         if (ret != Success)\r
 678         {\r
 679           fprintf(file, " ? ");\r
 680         }\r
 681         else\r
 682         {\r
 683           if (GLX_TRUE_COLOR == value)\r
 684             fprintf(file, "tc ");\r
 685           else if (GLX_DIRECT_COLOR == value)\r
 686             fprintf(file, "dc ");\r
 687           else if (GLX_PSEUDO_COLOR == value)\r
 688             fprintf(file, "pc ");\r
 689           else if (GLX_STATIC_COLOR == value)\r
 690             fprintf(file, "sc ");\r
 691           else if (GLX_GRAY_SCALE == value)\r
 692             fprintf(file, "gs ");\r
 693           else if (GLX_STATIC_GRAY == value)\r
 694             fprintf(file, "sg ");\r
 695           else if (GLX_X_VISUAL_TYPE == value)\r
 696             fprintf(file, " . ");\r
 697           else\r
 698             fprintf(file, " ? ");\r
 699         }\r
 700         /* format */\r
 701         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_RENDER_TYPE, &value);\r
 702         if (ret != Success)\r
 703         {\r
 704           fprintf(file, " ? ");\r
 705         }\r
 706         else\r
 707         {\r
 708           if (GLXEW_NV_float_buffer)\r
 709           {\r
 710             int ret2, value2;\r
 711             ret2 = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_FLOAT_COMPONENTS_NV, &value2);\r
 712             if (Success == ret2 && GL_TRUE == value2)\r
 713             {\r
 714               fprintf(file, " f ");\r
 715             }\r
 716             else if (value & GLX_RGBA_BIT)\r
 717               fprintf(file, " i ");\r
 718             else if (value & GLX_COLOR_INDEX_BIT)\r
 719               fprintf(file, " c ");\r
 720             else\r
 721               fprintf(file, " ? ");\r
 722           }\r
 723           else\r
 724           {\r
 725             if (value & GLX_RGBA_FLOAT_ATI_BIT)\r
 726               fprintf(file, " f ");\r
 727             else if (value & GLX_RGBA_BIT)\r
 728               fprintf(file, " i ");\r
 729             else if (value & GLX_COLOR_INDEX_BIT)\r
 730               fprintf(file, " c ");\r
 731             else\r
 732               fprintf(file, " ? ");\r
 733           }\r
 734         }\r
 735         /* double buffer */\r
 736         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DOUBLEBUFFER, &value);\r
 737         fprintf(file, " %c ", Success != ret ? '?' : (value ? 'y' : '.'));\r
 738         /* stereo */\r
 739         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_STEREO, &value);\r
 740         fprintf(file, " %c ", Success != ret ? '?' : (value ? 'y' : '.'));\r
 741         /* level */\r
 742         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_LEVEL, &value);\r
 743         if (Success != ret)\r
 744         {\r
 745           fprintf(file, " ? ");\r
 746         }\r
 747         else\r
 748         {\r
 749           fprintf(file, "%2d ", value);\r
 750         }\r
 751         /* transparency */\r
 752         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_TRANSPARENT_TYPE, &value);\r
 753         if (Success != ret)\r
 754         {\r
 755           fprintf(file, " ? | ");\r
 756         }\r
 757         else\r
 758         {\r
 759           if (GLX_TRANSPARENT_RGB == value)\r
 760             fprintf(file, " r | ");\r
 761           else if (GLX_TRANSPARENT_INDEX == value)\r
 762             fprintf(file, " i | ");\r
 763           else if (GLX_NONE == value)\r
 764             fprintf(file, " . | ");\r
 765           else\r
 766             fprintf(file, " ? | ");\r
 767         }\r
 768         /* color size */\r
 769         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_BUFFER_SIZE, &value);\r
 770         if (Success != ret)\r
 771         {\r
 772           fprintf(file, "  ? ");\r
 773         }\r
 774         else\r
 775         {\r
 776           if (value)\r
 777             fprintf(file, "%3d ", value);\r
 778           else\r
 779             fprintf(file, "  . ");\r
 780         }\r
 781         /* red size */\r
 782         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_RED_SIZE, &value);\r
 783         if (Success != ret)\r
 784         {\r
 785           fprintf(file, " ? ");\r
 786         }\r
 787         else\r
 788         {\r
 789           if (value)\r
 790             fprintf(file, "%2d ", value);\r
 791           else\r
 792             fprintf(file, " . ");\r
 793         }\r
 794         /* green size */\r
 795         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_GREEN_SIZE, &value);\r
 796         if (Success != ret)\r
 797         {\r
 798           fprintf(file, " ? ");\r
 799         }\r
 800         else\r
 801         {\r
 802           if (value)\r
 803             fprintf(file, "%2d ", value);\r
 804           else\r
 805             fprintf(file, " . ");\r
 806         }\r
 807         /* blue size */\r
 808         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_BLUE_SIZE, &value);\r
 809         if (Success != ret)\r
 810         {\r
 811           fprintf(file, " ? ");\r
 812         }\r
 813         else\r
 814         {\r
 815           if (value)\r
 816             fprintf(file, "%2d ", value);\r
 817           else\r
 818             fprintf(file, " . ");\r
 819         }\r
 820         /* alpha size */\r
 821         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ALPHA_SIZE, &value);\r
 822         if (Success != ret)\r
 823         {\r
 824           fprintf(file, " ? | ");\r
 825         }\r
 826         else\r
 827         {\r
 828           if (value)\r
 829             fprintf(file, "%2d | ", value);\r
 830           else\r
 831             fprintf(file, " . | ");\r
 832         }\r
 833         /* aux buffers */\r
 834         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_AUX_BUFFERS, &value);\r
 835         if (Success != ret)\r
 836         {\r
 837           fprintf(file, " ? ");\r
 838         }\r
 839         else\r
 840         {\r
 841           if (value)\r
 842             fprintf(file, "%2d ", value);\r
 843           else\r
 844             fprintf(file, " . ");\r
 845         }\r
 846         /* depth size */\r
 847         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DEPTH_SIZE, &value);\r
 848         if (Success != ret)\r
 849         {\r
 850           fprintf(file, " ? ");\r
 851         }\r
 852         else\r
 853         {\r
 854           if (value)\r
 855             fprintf(file, "%2d ", value);\r
 856           else\r
 857             fprintf(file, " . ");\r
 858         }\r
 859         /* stencil size */\r
 860         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_STENCIL_SIZE, &value);\r
 861         if (Success != ret)\r
 862         {\r
 863           fprintf(file, " ? | ");\r
 864         }\r
 865         else\r
 866         {\r
 867           if (value)\r
 868             fprintf(file, "%2d | ", value);\r
 869           else\r
 870             fprintf(file, " . | ");\r
 871         }\r
 872         /* accum red size */\r
 873         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_RED_SIZE, &value);\r
 874         if (Success != ret)\r
 875         {\r
 876           fprintf(file, " ? ");\r
 877         }\r
 878         else\r
 879         {\r
 880           if (value)\r
 881             fprintf(file, "%2d ", value);\r
 882           else\r
 883             fprintf(file, " . ");\r
 884         }\r
 885         /* accum green size */\r
 886         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_GREEN_SIZE, &value);\r
 887         if (Success != ret)\r
 888         {\r
 889           fprintf(file, " ? ");\r
 890         }\r
 891         else\r
 892         {\r
 893           if (value)\r
 894             fprintf(file, "%2d ", value);\r
 895           else\r
 896             fprintf(file, " . ");\r
 897         }\r
 898         /* accum blue size */\r
 899         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_BLUE_SIZE, &value);\r
 900         if (Success != ret)\r
 901         {\r
 902           fprintf(file, " ? ");\r
 903         }\r
 904         else\r
 905         {\r
 906           if (value)\r
 907             fprintf(file, "%2d ", value);\r
 908           else\r
 909             fprintf(file, " . ");\r
 910         }\r
 911         /* accum alpha size */\r
 912         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_ALPHA_SIZE, &value);\r
 913         if (Success != ret)\r
 914         {\r
 915           fprintf(file, " ? | ");\r
 916         }\r
 917         else\r
 918         {\r
 919           if (value)\r
 920             fprintf(file, "%2d | ", value);\r
 921           else\r
 922             fprintf(file, " . | ");\r
 923         }\r
 924         /* multisample */\r
 925         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_SAMPLES, &value);\r
 926         if (Success != ret)\r
 927         {\r
 928           fprintf(file, " ? ");\r
 929         }\r
 930         else\r
 931         {\r
 932           fprintf(file, "%2d ", value);\r
 933         }\r
 934         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_SAMPLE_BUFFERS, &value);\r
 935         if (Success != ret)\r
 936         {\r
 937           fprintf(file, " ? | ");\r
 938         }\r
 939         else\r
 940         {\r
 941           fprintf(file, "%2d | ", value);\r
 942         }\r
 943         /* caveat */\r
 944         ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_CONFIG_CAVEAT, &value);\r
 945         if (Success != ret)\r
 946         {\r
 947           fprintf(file, "???? |");\r
 948         }\r
 949         else\r
 950         {\r
 951           if (GLX_NONE == value)\r
 952             fprintf(file, "none |\n");\r
 953           else if (GLX_SLOW_CONFIG == value)\r
 954             fprintf(file, "slow |\n");\r
 955           else if (GLX_NON_CONFORMANT_CONFIG == value)\r
 956             fprintf(file, "ncft |\n");\r
 957           else\r
 958             fprintf(file, "???? |\n");\r
 959         }\r
 960       }\r
 961       /* print table footer */\r
 962       fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");\r
 963       fprintf(file, " |  id | tp xr cl fm db st lv xp |  sz  r  g  b  a | bf th cl | r  g  b  a  | ns  b |  eat |\n");\r
 964       fprintf(file, " |     |        visual           |      color      | ax dp st |    accum    |   ms  |  cav |\n");\r
 965       fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");\r
 966     }\r
 967   }\r
 968 }\r
 969 \r
 970 #endif\r
 971 \r
 972 /* ------------------------------------------------------------------------ */\r
 973 \r
 974 #if defined(_WIN32)\r
 975 \r
 976 void InitContext (GLContext* ctx)\r
 977 {\r
 978   ctx->wnd = NULL;\r
 979   ctx->dc = NULL;\r
 980   ctx->rc = NULL;\r
 981 }\r
 982 \r
 983 GLboolean CreateContext (GLContext* ctx)\r
 984 {\r
 985   WNDCLASS wc;\r
 986   PIXELFORMATDESCRIPTOR pfd;\r
 987   /* check for input */\r
 988   if (NULL == ctx) return GL_TRUE;\r
 989   /* register window class */\r
 990   ZeroMemory(&wc, sizeof(WNDCLASS));\r
 991   wc.hInstance = GetModuleHandle(NULL);\r
 992   wc.lpfnWndProc = DefWindowProc;\r
 993   wc.lpszClassName = "GLEW";\r
 994   if (0 == RegisterClass(&wc)) return GL_TRUE;\r
 995   /* create window */\r
 996   ctx->wnd = CreateWindow("GLEW", "GLEW", 0, CW_USEDEFAULT, CW_USEDEFAULT, \r
 997                           CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, \r
 998                           GetModuleHandle(NULL), NULL);\r
 999   if (NULL == ctx->wnd) return GL_TRUE;\r
1000   /* get the device context */\r
1001   ctx->dc = GetDC(ctx->wnd);\r
1002   if (NULL == ctx->dc) return GL_TRUE;\r
1003   /* find pixel format */\r
1004   ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));\r
1005   if (visual == -1) /* find default */\r
1006   {\r
1007     pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);\r
1008     pfd.nVersion = 1;\r
1009     pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;\r
1010     visual = ChoosePixelFormat(ctx->dc, &pfd);\r
1011     if (0 == visual) return GL_TRUE;\r
1012   }\r
1013   /* set the pixel format for the dc */\r
1014   if (FALSE == SetPixelFormat(ctx->dc, visual, &pfd)) return GL_TRUE;\r
1015   /* create rendering context */\r
1016   ctx->rc = wglCreateContext(ctx->dc);\r
1017   if (NULL == ctx->rc) return GL_TRUE;\r
1018   if (FALSE == wglMakeCurrent(ctx->dc, ctx->rc)) return GL_TRUE;\r
1019   return GL_FALSE;\r
1020 }\r
1021 \r
1022 void DestroyContext (GLContext* ctx)\r
1023 {\r
1024   if (NULL == ctx) return;\r
1025   if (NULL != ctx->rc) wglMakeCurrent(NULL, NULL);\r
1026   if (NULL != ctx->rc) wglDeleteContext(wglGetCurrentContext());\r
1027   if (NULL != ctx->wnd && NULL != ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);\r
1028   if (NULL != ctx->wnd) DestroyWindow(ctx->wnd);\r
1029   UnregisterClass("GLEW", GetModuleHandle(NULL));\r
1030 }\r
1031 \r
1032 /* ------------------------------------------------------------------------ */\r
1033 \r
1034 #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)\r
1035 \r
1036 void InitContext (GLContext* ctx)\r
1037 {\r
1038   ctx->ctx = NULL;\r
1039   ctx->octx = NULL;\r
1040 }\r
1041 \r
1042 GLboolean CreateContext (GLContext* ctx)\r
1043 {\r
1044   int attrib[] = { AGL_RGBA, AGL_NONE };\r
1045   AGLPixelFormat pf;\r
1046   /* check input */\r
1047   if (NULL == ctx) return GL_TRUE;\r
1048   /*int major, minor;\r
1049   SetPortWindowPort(wnd);\r
1050   aglGetVersion(&major, &minor);\r
1051   fprintf(stderr, "GL %d.%d\n", major, minor);*/\r
1052   pf = aglChoosePixelFormat(NULL, 0, attrib);\r
1053   if (NULL == pf) return GL_TRUE;\r
1054   ctx->ctx = aglCreateContext(pf, NULL);\r
1055   if (NULL == ctx->ctx || AGL_NO_ERROR != aglGetError()) return GL_TRUE;\r
1056   aglDestroyPixelFormat(pf);\r
1057   /*aglSetDrawable(ctx, GetWindowPort(wnd));*/\r
1058   ctx->octx = aglGetCurrentContext();\r
1059   if (NULL == aglSetCurrentContext(ctx->ctx)) return GL_TRUE;\r
1060   return GL_FALSE;\r
1061 }\r
1062 \r
1063 void DestroyContext (GLContext* ctx)\r
1064 {\r
1065   if (NULL == ctx) return;\r
1066   aglSetCurrentContext(ctx->octx);\r
1067   if (NULL != ctx->ctx) aglDestroyContext(ctx->ctx);\r
1068 }\r
1069 \r
1070 /* ------------------------------------------------------------------------ */\r
1071 \r
1072 #else /* __UNIX || (__APPLE__ && GLEW_APPLE_GLX) */\r
1073 \r
1074 void InitContext (GLContext* ctx)\r
1075 {\r
1076   ctx->dpy = NULL;\r
1077   ctx->vi = NULL;\r
1078   ctx->ctx = NULL;\r
1079   ctx->wnd = 0;\r
1080   ctx->cmap = 0;\r
1081 }\r
1082 \r
1083 GLboolean CreateContext (GLContext* ctx)\r
1084 {\r
1085   int attrib[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None };\r
1086   int erb, evb;\r
1087   XSetWindowAttributes swa;\r
1088   /* check input */\r
1089   if (NULL == ctx) return GL_TRUE;\r
1090   /* open display */\r
1091   ctx->dpy = XOpenDisplay(display);\r
1092   if (NULL == ctx->dpy) return GL_TRUE;\r
1093   /* query for glx */\r
1094   if (!glXQueryExtension(ctx->dpy, &erb, &evb)) return GL_TRUE;\r
1095   /* choose visual */\r
1096   ctx->vi = glXChooseVisual(ctx->dpy, DefaultScreen(ctx->dpy), attrib);\r
1097   if (NULL == ctx->vi) return GL_TRUE;\r
1098   /* create context */\r
1099   ctx->ctx = glXCreateContext(ctx->dpy, ctx->vi, None, True);\r
1100   if (NULL == ctx->ctx) return GL_TRUE;\r
1101   /* create window */\r
1102   /*wnd = XCreateSimpleWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, 1, 1, 1, 0, 0);*/\r
1103   ctx->cmap = XCreateColormap(ctx->dpy, RootWindow(ctx->dpy, ctx->vi->screen),\r
1104                               ctx->vi->visual, AllocNone);\r
1105   swa.border_pixel = 0;\r
1106   swa.colormap = ctx->cmap;\r
1107   ctx->wnd = XCreateWindow(ctx->dpy, RootWindow(ctx->dpy, ctx->vi->screen), \r
1108                            0, 0, 1, 1, 0, ctx->vi->depth, InputOutput, ctx->vi->visual, \r
1109                            CWBorderPixel | CWColormap, &swa);\r
1110   /* make context current */\r
1111   if (!glXMakeCurrent(ctx->dpy, ctx->wnd, ctx->ctx)) return GL_TRUE;\r
1112   return GL_FALSE;\r
1113 }\r
1114 \r
1115 void DestroyContext (GLContext* ctx)\r
1116 {\r
1117   if (NULL != ctx->dpy && NULL != ctx->ctx) glXDestroyContext(ctx->dpy, ctx->ctx);\r
1118   if (NULL != ctx->dpy && 0 != ctx->wnd) XDestroyWindow(ctx->dpy, ctx->wnd);\r
1119   if (NULL != ctx->dpy && 0 != ctx->cmap) XFreeColormap(ctx->dpy, ctx->cmap);\r
1120   if (NULL != ctx->vi) XFree(ctx->vi);\r
1121   if (NULL != ctx->dpy) XCloseDisplay(ctx->dpy);\r
1122 }\r
1123 \r
1124 #endif /* __UNIX || (__APPLE__ && GLEW_APPLE_GLX) */\r
1125 \r
1126 GLboolean ParseArgs (int argc, char** argv)\r
1127 {\r
1128   int p = 0;\r
1129   while (p < argc)\r
1130   {\r
1131 #if defined(_WIN32)\r
1132     if (!strcmp(argv[p], "-pf") || !strcmp(argv[p], "-pixelformat"))\r
1133     {\r
1134       if (++p >= argc) return GL_TRUE;\r
1135       display = NULL;\r
1136       visual = strtol(argv[p], NULL, 0);\r
1137     }\r
1138     else if (!strcmp(argv[p], "-a"))\r
1139     {\r
1140       showall = 1;\r
1141     }\r
1142     else if (!strcmp(argv[p], "-s"))\r
1143     {\r
1144       displaystdout = 1;\r
1145     }\r
1146     else if (!strcmp(argv[p], "-h"))\r
1147     {\r
1148       return GL_TRUE;\r
1149     }\r
1150     else\r
1151       return GL_TRUE;\r
1152 #else\r
1153     if (!strcmp(argv[p], "-display"))\r
1154     {\r
1155       if (++p >= argc) return GL_TRUE;\r
1156       display = argv[p];\r
1157     }\r
1158     else if (!strcmp(argv[p], "-visual"))\r
1159     {\r
1160       if (++p >= argc) return GL_TRUE;\r
1161       visual = (int)strtol(argv[p], NULL, 0);\r
1162     }\r
1163     else if (!strcmp(argv[p], "-h"))\r
1164     {\r
1165       return GL_TRUE;\r
1166     }\r
1167     else\r
1168       return GL_TRUE;\r
1169 #endif\r
1170     p++;\r
1171   }\r
1172   return GL_FALSE;\r
1173 }\r