CoCalc -- visualinfo.c

CoCalc provides the best real-time collaborative environment for Jupyter Notebooks, LaTeX documents, and SageMath, scalable from individual users to large groups and classes!

GitHub Repository: hrydgard/ppsspp
Path: blob/master/ext/glew/visualinfo.c
Views: ¹⁴⁰¹
1
/*
2
** visualinfo.c
3
**
4
** Copyright (C) Nate Robins, 1997
5
**               Michael Wimmer, 1999
6
**               Milan Ikits, 2002-2008
7
**               Nigel Stewart, 2008-2013
8
**
9
** visualinfo is a small utility that displays all available visuals,
10
** aka. pixelformats, in an OpenGL system along with renderer version
11
** information. It shows a table of all the visuals that support OpenGL
12
** along with their capabilities. The format of the table is similar to
13
** that of glxinfo on Unix systems:
14
**
15
** visual ~= pixel format descriptor
16
** id       = visual id (integer from 1 - max visuals)
17
** tp       = type (wn: window, pb: pbuffer, wp: window & pbuffer, bm: bitmap)
18
** ac	    = acceleration (ge: generic, fu: full, no: none)
19
** fm	    = format (i: integer, f: float, c: color index)
20
** db	    = double buffer (y = yes)
21
** sw       = swap method (x: exchange, c: copy, u: undefined)
22
** st	    = stereo (y = yes)
23
** sz       = total # bits
24
** r        = # bits of red
25
** g        = # bits of green
26
** b        = # bits of blue
27
** a        = # bits of alpha
28
** axbf     = # aux buffers
29
** dpth     = # bits of depth
30
** stcl     = # bits of stencil
31
*/
32

33
#include <stdio.h>
34
#include <stdlib.h>
35
#include <string.h>
36
#include <GL/glew.h>
37
#if defined(GLEW_OSMESA)
38
#define GLAPI extern
39
#include <GL/osmesa.h>
40
#elif defined(GLEW_EGL)
41
#include <GL/eglew.h>
42
#elif defined(_WIN32)
43
#include <GL/wglew.h>
44
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
45
#include <OpenGL/OpenGL.h>
46
#include <OpenGL/CGLTypes.h>
47
#elif !defined(__HAIKU__)
48
#include <GL/glxew.h>
49
#endif
50

51
#ifdef GLEW_MX
52
GLEWContext _glewctx;
53
#  define glewGetContext() (&_glewctx)
54
#  ifdef _WIN32
55
WGLEWContext _wglewctx;
56
#    define wglewGetContext() (&_wglewctx)
57
#  elif !defined(__APPLE__) && !defined(__HAIKU__) || defined(GLEW_APPLE_GLX)
58
GLXEWContext _glxewctx;
59
#    define glxewGetContext() (&_glxewctx)
60
#  endif
61
#endif /* GLEW_MX */
62

63
typedef struct GLContextStruct
64
{
65
#if defined(GLEW_OSMESA)
66
  OSMesaContext ctx;
67
#elif defined(GLEW_EGL)
68
  EGLContext ctx;
69
#elif defined(_WIN32)
70
  HWND wnd;
71
  HDC dc;
72
  HGLRC rc;
73
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
74
  CGLContextObj ctx, octx;
75
#elif !defined(__HAIKU__)
76
  Display* dpy;
77
  XVisualInfo* vi;
78
  GLXContext ctx;
79
  Window wnd;
80
  Colormap cmap;
81
#endif
82
} GLContext;
83

84
void InitContext (GLContext* ctx);
85
GLboolean CreateContext (GLContext* ctx);
86
void DestroyContext (GLContext* ctx);
87
void VisualInfo (GLContext* ctx);
88
void PrintExtensions (const char* s);
89
GLboolean ParseArgs (int argc, char** argv);
90

91
int showall = 0;
92
int displaystdout = 0;
93
int verbose = 0;
94
int drawableonly = 0;
95

96
char* display = NULL;
97
int visual = -1;
98

99
FILE* file = 0;
100

101
int 
102
main (int argc, char** argv)
103
{
104
  GLenum err;
105
  GLContext ctx;
106

107
  /* ---------------------------------------------------------------------- */
108
  /* parse arguments */
109
  if (GL_TRUE == ParseArgs(argc-1, argv+1))
110
  {
111
#if defined(_WIN32)
112
    fprintf(stderr, "Usage: visualinfo [-a] [-s] [-h] [-pf <id>]\n");
113
    fprintf(stderr, "        -a: show all visuals\n");
114
    fprintf(stderr, "        -s: display to stdout instead of visualinfo.txt\n");
115
    fprintf(stderr, "        -pf <id>: use given pixelformat\n");
116
    fprintf(stderr, "        -h: this screen\n");
117
#else
118
    fprintf(stderr, "Usage: visualinfo [-h] [-display <display>] [-visual <id>]\n");
119
    fprintf(stderr, "        -h: this screen\n");
120
    fprintf(stderr, "        -display <display>: use given display\n");
121
    fprintf(stderr, "        -visual <id>: use given visual\n");
122
#endif
123
    return 1;
124
  }
125

126
  /* ---------------------------------------------------------------------- */
127
  /* create OpenGL rendering context */
128
  InitContext(&ctx);
129
  if (GL_TRUE == CreateContext(&ctx))
130
  {
131
    fprintf(stderr, "Error: CreateContext failed\n");
132
    DestroyContext(&ctx);
133
    return 1;
134
  }
135

136
  /* ---------------------------------------------------------------------- */
137
  /* initialize GLEW */
138
  glewExperimental = GL_TRUE;
139
#ifdef GLEW_MX
140
  err = glewContextInit(glewGetContext());
141
#  ifdef _WIN32
142
  err = err || wglewContextInit(wglewGetContext());
143
#  elif !defined(__APPLE__) && !defined(__HAIKU__) || defined(GLEW_APPLE_GLX)
144
  err = err || glxewContextInit(glxewGetContext());
145
#  endif
146
#else
147
  err = glewInit();
148
#endif
149
  if (GLEW_OK != err)
150
  {
151
    fprintf(stderr, "Error [main]: glewInit failed: %s\n", glewGetErrorString(err));
152
    DestroyContext(&ctx);
153
    return 1;
154
  }
155

156
  /* ---------------------------------------------------------------------- */
157
  /* open file */
158
#if defined(_WIN32)
159
  if (!displaystdout)
160
  {
161
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
162
    if (fopen_s(&file, "visualinfo.txt", "w") != 0)
163
      file = stdout;
164
#else
165
    file = fopen("visualinfo.txt", "w");
166
#endif
167
  }
168
  if (file == NULL)
169
    file = stdout;
170
#else
171
  file = stdout;
172
#endif
173

174
  /* ---------------------------------------------------------------------- */
175
  /* output header information */
176
  /* OpenGL extensions */
177
  fprintf(file, "OpenGL vendor string: %s\n", glGetString(GL_VENDOR));
178
  fprintf(file, "OpenGL renderer string: %s\n", glGetString(GL_RENDERER));
179
  fprintf(file, "OpenGL version string: %s\n", glGetString(GL_VERSION));
180
  fprintf(file, "OpenGL extensions (GL_): \n");
181
  PrintExtensions((const char*)glGetString(GL_EXTENSIONS));
182

183
#ifndef GLEW_NO_GLU
184
  /* GLU extensions */
185
  fprintf(file, "GLU version string: %s\n", gluGetString(GLU_VERSION));
186
  fprintf(file, "GLU extensions (GLU_): \n");
187
  PrintExtensions((const char*)gluGetString(GLU_EXTENSIONS));
188
#endif
189

190
  /* ---------------------------------------------------------------------- */
191
  /* extensions string */
192
#if defined(GLEW_OSMESA)
193
#elif defined(GLEW_EGL)
194
#elif defined(_WIN32)
195
  /* WGL extensions */
196
  if (WGLEW_ARB_extensions_string || WGLEW_EXT_extensions_string)
197
  {
198
    fprintf(file, "WGL extensions (WGL_): \n");
199
    PrintExtensions(wglGetExtensionsStringARB ? 
200
                    (const char*)wglGetExtensionsStringARB(ctx.dc) :
201
		    (const char*)wglGetExtensionsStringEXT());
202
  }
203
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
204
  
205
#elif defined(__HAIKU__)
206

207
  /* TODO */
208

209
#else
210
  /* GLX extensions */
211
  fprintf(file, "GLX extensions (GLX_): \n");
212
  PrintExtensions(glXQueryExtensionsString(glXGetCurrentDisplay(), 
213
                                           DefaultScreen(glXGetCurrentDisplay())));
214
#endif
215

216
  /* ---------------------------------------------------------------------- */
217
  /* enumerate all the formats */
218
  VisualInfo(&ctx);
219

220
  /* ---------------------------------------------------------------------- */
221
  /* release resources */
222
  DestroyContext(&ctx);
223
  if (file != stdout)
224
    fclose(file);
225
  return 0;
226
}
227

228
/* do the magic to separate all extensions with comma's, except
229
   for the last one that _may_ terminate in a space. */
230
void PrintExtensions (const char* s)
231
{
232
  char t[80];
233
  int i=0;
234
  char* p=0;
235

236
  t[79] = '\0';
237
  while (*s)
238
  {
239
    t[i++] = *s;
240
    if(*s == ' ')
241
    {
242
      if (*(s+1) != '\0') {
243
	t[i-1] = ',';
244
	t[i] = ' ';
245
	p = &t[i++];
246
      }
247
      else /* zoinks! last one terminated in a space! */
248
      {
249
	t[i-1] = '\0';
250
      }
251
    }
252
    if(i > 80 - 5)
253
    {
254
      *p = t[i] = '\0';
255
      fprintf(file, "    %s\n", t);
256
      p++;
257
      i = (int)strlen(p);
258
#if defined(_MSC_VER) && (_MSC_VER >= 1400)
259
      strcpy_s(t, sizeof(t), p);
260
#else
261
      strcpy(t, p);
262
#endif
263
    }
264
    s++;
265
  }
266
  t[i] = '\0';
267
  fprintf(file, "    %s.\n", t);
268
}
269

270
/* ---------------------------------------------------------------------- */
271

272
#if defined(GLEW_OSMESA) || defined(GLEW_EGL)
273

274
void
275
VisualInfo (GLContext* ctx)
276
{
277
}
278

279
#elif defined(_WIN32)
280

281
void
282
VisualInfoARB (GLContext* ctx)
283
{
284
  int attrib[32], value[32], n_attrib, n_pbuffer=0, n_float=0;
285
  int i, pf, maxpf;
286
  unsigned int c;
287

288
  /* to get pbuffer capable pixel formats */
289
  attrib[0] = WGL_DRAW_TO_PBUFFER_ARB;
290
  attrib[1] = GL_TRUE;
291
  attrib[2] = 0;
292
  wglChoosePixelFormatARB(ctx->dc, attrib, 0, 1, &pf, &c);
293
  /* query number of pixel formats */
294
  attrib[0] = WGL_NUMBER_PIXEL_FORMATS_ARB;
295
  wglGetPixelFormatAttribivARB(ctx->dc, 0, 0, 1, attrib, value);
296
  maxpf = value[0];
297
  for (i=0; i<32; i++)
298
    value[i] = 0;
299

300
  attrib[0] = WGL_SUPPORT_OPENGL_ARB;
301
  attrib[1] = WGL_DRAW_TO_WINDOW_ARB;
302
  attrib[2] = WGL_DRAW_TO_BITMAP_ARB;
303
  attrib[3] = WGL_ACCELERATION_ARB;
304
  /* WGL_NO_ACCELERATION_ARB, WGL_GENERIC_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB */
305
  attrib[4] = WGL_SWAP_METHOD_ARB;
306
  /* WGL_SWAP_EXCHANGE_ARB, WGL_SWAP_COPY_ARB, WGL_SWAP_UNDEFINED_ARB */
307
  attrib[5] = WGL_DOUBLE_BUFFER_ARB;
308
  attrib[6] = WGL_STEREO_ARB;
309
  attrib[7] = WGL_PIXEL_TYPE_ARB;
310
  /* WGL_TYPE_RGBA_ARB, WGL_TYPE_COLORINDEX_ARB,
311
     WGL_TYPE_RGBA_FLOAT_ATI (WGL_ATI_pixel_format_float) */
312
  /* Color buffer information */
313
  attrib[8] = WGL_COLOR_BITS_ARB;
314
  attrib[9] = WGL_RED_BITS_ARB;
315
  attrib[10] = WGL_GREEN_BITS_ARB;
316
  attrib[11] = WGL_BLUE_BITS_ARB;
317
  attrib[12] = WGL_ALPHA_BITS_ARB;
318
  /* Accumulation buffer information */
319
  attrib[13] = WGL_ACCUM_BITS_ARB;
320
  attrib[14] = WGL_ACCUM_RED_BITS_ARB;
321
  attrib[15] = WGL_ACCUM_GREEN_BITS_ARB;
322
  attrib[16] = WGL_ACCUM_BLUE_BITS_ARB;
323
  attrib[17] = WGL_ACCUM_ALPHA_BITS_ARB;
324
  /* Depth, stencil, and aux buffer information */
325
  attrib[18] = WGL_DEPTH_BITS_ARB;
326
  attrib[19] = WGL_STENCIL_BITS_ARB;
327
  attrib[20] = WGL_AUX_BUFFERS_ARB;
328
  /* Layer information */
329
  attrib[21] = WGL_NUMBER_OVERLAYS_ARB;
330
  attrib[22] = WGL_NUMBER_UNDERLAYS_ARB;
331
  attrib[23] = WGL_SWAP_LAYER_BUFFERS_ARB;
332
  attrib[24] = WGL_SAMPLES_ARB;
333
  attrib[25] = WGL_SUPPORT_GDI_ARB;
334
  n_attrib = 26;
335
  if (WGLEW_ARB_pbuffer)
336
  {
337
    attrib[n_attrib] = WGL_DRAW_TO_PBUFFER_ARB;
338
    n_pbuffer = n_attrib;
339
    n_attrib++;
340
  }
341
  if (WGLEW_NV_float_buffer)
342
  {
343
    attrib[n_attrib] = WGL_FLOAT_COMPONENTS_NV;
344
    n_float = n_attrib;
345
    n_attrib++;
346
  }
347
  
348
  if (!verbose)
349
  {
350
    /* print table header */
351
    fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");
352
    fprintf(file, " |     |          visual         |      color      | ax dp st |      accum      |   layer  |\n");
353
    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");
354
    fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");
355
    /* loop through all the pixel formats */
356
    for(i = 1; i <= maxpf; i++)
357
    {
358
      wglGetPixelFormatAttribivARB(ctx->dc, i, 0, n_attrib, attrib, value);
359
      /* only describe this format if it supports OpenGL */
360
      if (!value[0]) continue;
361
      /* by default show only fully accelerated window or pbuffer capable visuals */
362
      if (!showall
363
	  && ((value[2] && !value[1])
364
	  || (!WGLEW_ARB_pbuffer || !value[n_pbuffer])
365
	  || (value[3] != WGL_FULL_ACCELERATION_ARB))) continue;
366
      /* print out the information for this visual */
367
      /* visual id */
368
      fprintf(file, " |% 4d | ", i);
369
      /* visual type */
370
      if (value[1])
371
      {
372
	if (WGLEW_ARB_pbuffer && value[n_pbuffer]) fprintf(file, "wp ");
373
	else fprintf(file, "wn ");
374
      }
375
      else
376
      {
377
	if (value[2]) fprintf(file, "bm ");
378
	else if (WGLEW_ARB_pbuffer && value[n_pbuffer]) fprintf(file, "pb ");
379
      }
380
      /* acceleration */
381
      fprintf(file, "%s ", value[3] == WGL_FULL_ACCELERATION_ARB ? "fu" : 
382
	      value[3] == WGL_GENERIC_ACCELERATION_ARB ? "ge" :
383
	      value[3] == WGL_NO_ACCELERATION_ARB ? "no" : ". ");
384
      /* gdi support */
385
      fprintf(file, " %c ", value[25] ? 'y' : '.');
386
      /* format */
387
      if (WGLEW_NV_float_buffer && value[n_float]) fprintf(file, " f ");
388
      else if (WGLEW_ATI_pixel_format_float && value[7] == WGL_TYPE_RGBA_FLOAT_ATI) fprintf(file, " f ");
389
      else if (value[7] == WGL_TYPE_RGBA_ARB) fprintf(file, " i ");
390
      else if (value[7] == WGL_TYPE_COLORINDEX_ARB) fprintf(file, " c ");
391
      else if (value[7] == WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT) fprintf(file," p ");
392
      else fprintf(file," ? ");
393
      /* double buffer */
394
      fprintf(file, " %c ", value[5] ? 'y' : '.');
395
      /* swap method */
396
      if (value[4] == WGL_SWAP_EXCHANGE_ARB) fprintf(file, " x ");
397
      else if (value[4] == WGL_SWAP_COPY_ARB) fprintf(file, " c ");
398
      else if (value[4] == WGL_SWAP_UNDEFINED_ARB) fprintf(file, " . ");
399
      else fprintf(file, " . ");
400
      /* stereo */
401
      fprintf(file, " %c ", value[6] ? 'y' : '.');
402
      /* multisample */
403
      if (value[24] > 0)
404
	fprintf(file, "%2d | ", value[24]);
405
      else
406
	fprintf(file, " . | ");
407
      /* color size */
408
      if (value[8]) fprintf(file, "%3d ", value[8]);
409
      else fprintf(file, "  . ");
410
      /* red */
411
      if (value[9]) fprintf(file, "%2d ", value[9]); 
412
      else fprintf(file, " . ");
413
      /* green */
414
      if (value[10]) fprintf(file, "%2d ", value[10]); 
415
      else fprintf(file, " . ");
416
      /* blue */
417
      if (value[11]) fprintf(file, "%2d ", value[11]);
418
      else fprintf(file, " . ");
419
      /* alpha */
420
      if (value[12]) fprintf(file, "%2d | ", value[12]); 
421
      else fprintf(file, " . | ");
422
      /* aux buffers */
423
      if (value[20]) fprintf(file, "%2d ", value[20]);
424
      else fprintf(file, " . ");
425
      /* depth */
426
      if (value[18]) fprintf(file, "%2d ", value[18]);
427
      else fprintf(file, " . ");
428
      /* stencil */
429
      if (value[19]) fprintf(file, "%2d | ", value[19]);
430
      else fprintf(file, " . | ");
431
      /* accum size */
432
      if (value[13]) fprintf(file, "%3d ", value[13]);
433
      else fprintf(file, "  . ");
434
      /* accum red */
435
      if (value[14]) fprintf(file, "%2d ", value[14]);
436
      else fprintf(file, " . ");
437
      /* accum green */
438
      if (value[15]) fprintf(file, "%2d ", value[15]);
439
      else fprintf(file, " . ");
440
      /* accum blue */
441
      if (value[16]) fprintf(file, "%2d ", value[16]);
442
      else fprintf(file, " . ");
443
      /* accum alpha */
444
      if (value[17]) fprintf(file, "%2d | ", value[17]);
445
      else fprintf(file, " . | ");
446
      /* overlay */
447
      if (value[21]) fprintf(file, "%2d ", value[21]);
448
      else fprintf(file, " . ");
449
      /* underlay */
450
      if (value[22]) fprintf(file, "%2d ", value[22]);
451
      else fprintf(file, " . ");
452
      /* layer swap */
453
      if (value[23]) fprintf(file, "y ");
454
      else fprintf(file, " . ");
455
      fprintf(file, "|\n");
456
    }
457
    /* print table footer */
458
    fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");
459
    fprintf(file, " |     |          visual         |      color      | ax dp st |      accum      |   layer  |\n");
460
    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");
461
    fprintf(file, " +-----+-------------------------+-----------------+----------+-----------------+----------+\n");
462
  }
463
  else /* verbose */
464
  {
465
#if 0
466
    fprintf(file, "\n");
467
    /* loop through all the pixel formats */
468
    for(i = 1; i <= maxpf; i++)
469
    {	    
470
      DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
471
      /* only describe this format if it supports OpenGL */
472
      if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)
473
	 || (drawableonly && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))) continue;
474
      fprintf(file, "Visual ID: %2d  depth=%d  class=%s\n", i, pfd.cDepthBits, 
475
	     pfd.cColorBits <= 8 ? "PseudoColor" : "TrueColor");
476
      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);
477
      fprintf(file, "    generic=%d generic accelerated=%d\n", (pfd.dwFlags & PFD_GENERIC_FORMAT) == PFD_GENERIC_FORMAT, (pfd.dwFlags & PFD_GENERIC_ACCELERATED) == PFD_GENERIC_ACCELERATED);
478
      fprintf(file, "    rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cRedBits, pfd.cGreenBits, pfd.cBlueBits, pfd.cAlphaBits);
479
      fprintf(file, "    auxBuffers=%d depthSize=%d stencilSize=%d\n", pfd.cAuxBuffers, pfd.cDepthBits, pfd.cStencilBits);
480
      fprintf(file, "    accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cAccumRedBits, pfd.cAccumGreenBits, pfd.cAccumBlueBits, pfd.cAccumAlphaBits);
481
      fprintf(file, "    multiSample=%d multisampleBuffers=%d\n", 0, 0);
482
      fprintf(file, "    Opaque.\n");
483
    }
484
#endif
485
  }
486
}
487

488
void
489
VisualInfoGDI (GLContext* ctx)
490
{
491
  int i, maxpf;
492
  PIXELFORMATDESCRIPTOR pfd;
493

494
  /* calling DescribePixelFormat() with NULL pfd (!!!) return maximum
495
     number of pixel formats */
496
  maxpf = DescribePixelFormat(ctx->dc, 1, 0, NULL);
497

498
  if (!verbose)
499
  {
500
    fprintf(file, "-----------------------------------------------------------------------------\n");
501
    fprintf(file, "   visual   x  bf  lv rg d st ge ge  r  g  b a  ax dp st   accum buffs    ms \n");
502
    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");
503
    fprintf(file, "-----------------------------------------------------------------------------\n");
504

505
    /* loop through all the pixel formats */
506
    for(i = 1; i <= maxpf; i++)
507
    {
508
      DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
509
      /* only describe this format if it supports OpenGL */
510
      if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)
511
	 || (drawableonly && (pfd.dwFlags & PFD_DRAW_TO_BITMAP))) continue;
512
      /* other criteria could be tested here for actual pixel format
513
	 choosing in an application:
514
	   
515
	 for (...each pixel format...) {
516
	 if (pfd.dwFlags & PFD_SUPPORT_OPENGL &&
517
	 pfd.dwFlags & PFD_DOUBLEBUFFER &&
518
	 pfd.cDepthBits >= 24 &&
519
	 pfd.cColorBits >= 24)
520
	 {
521
	 goto found;
522
	 }
523
	 }
524
	 ... not found so exit ...
525
	 found:
526
	 ... found so use it ...
527
      */
528
      /* print out the information for this pixel format */
529
      fprintf(file, "0x%02x ", i);
530
      fprintf(file, "%3d ", pfd.cColorBits);
531
      if(pfd.dwFlags & PFD_DRAW_TO_WINDOW) fprintf(file, "wn ");
532
      else if(pfd.dwFlags & PFD_DRAW_TO_BITMAP) fprintf(file, "bm ");
533
      else fprintf(file, "pb ");
534
      /* should find transparent pixel from LAYERPLANEDESCRIPTOR */
535
      fprintf(file, " . "); 
536
      fprintf(file, "%3d ", pfd.cColorBits);
537
      /* bReserved field indicates number of over/underlays */
538
      if(pfd.bReserved) fprintf(file, " %d ", pfd.bReserved);
539
      else fprintf(file, " . "); 
540
      fprintf(file, " %c ", pfd.iPixelType == PFD_TYPE_RGBA ? 'r' : 'c');
541
      fprintf(file, "%c ", pfd.dwFlags & PFD_DOUBLEBUFFER ? 'y' : '.');
542
      fprintf(file, " %c ", pfd.dwFlags & PFD_STEREO ? 'y' : '.');
543
      /* added: */
544
      fprintf(file, " %c ", pfd.dwFlags & PFD_GENERIC_FORMAT ? 'y' : '.');
545
      fprintf(file, " %c ", pfd.dwFlags & PFD_GENERIC_ACCELERATED ? 'y' : '.');
546
      if(pfd.cRedBits && pfd.iPixelType == PFD_TYPE_RGBA) 
547
	fprintf(file, "%2d ", pfd.cRedBits);
548
      else fprintf(file, " . ");
549
      if(pfd.cGreenBits && pfd.iPixelType == PFD_TYPE_RGBA) 
550
	fprintf(file, "%2d ", pfd.cGreenBits);
551
      else fprintf(file, " . ");
552
      if(pfd.cBlueBits && pfd.iPixelType == PFD_TYPE_RGBA) 
553
	fprintf(file, "%2d ", pfd.cBlueBits);
554
      else fprintf(file, " . ");
555
      if(pfd.cAlphaBits && pfd.iPixelType == PFD_TYPE_RGBA) 
556
	fprintf(file, "%2d ", pfd.cAlphaBits);
557
      else fprintf(file, " . ");
558
      if(pfd.cAuxBuffers)     fprintf(file, "%2d ", pfd.cAuxBuffers);
559
      else fprintf(file, " . ");
560
      if(pfd.cDepthBits)      fprintf(file, "%2d ", pfd.cDepthBits);
561
      else fprintf(file, " . ");
562
      if(pfd.cStencilBits)    fprintf(file, "%2d ", pfd.cStencilBits);
563
      else fprintf(file, " . ");
564
      if(pfd.cAccumBits)   fprintf(file, "%3d ", pfd.cAccumBits);
565
      else fprintf(file, "  . ");
566
      if(pfd.cAccumRedBits)   fprintf(file, "%2d ", pfd.cAccumRedBits);
567
      else fprintf(file, " . ");
568
      if(pfd.cAccumGreenBits) fprintf(file, "%2d ", pfd.cAccumGreenBits);
569
      else fprintf(file, " . ");
570
      if(pfd.cAccumBlueBits)  fprintf(file, "%2d ", pfd.cAccumBlueBits);
571
      else fprintf(file, " . ");
572
      if(pfd.cAccumAlphaBits) fprintf(file, "%2d ", pfd.cAccumAlphaBits);
573
      else fprintf(file, " . ");
574
      /* no multisample in win32 */
575
      fprintf(file, " . .\n");
576
    }
577
    /* print table footer */
578
    fprintf(file, "-----------------------------------------------------------------------------\n");
579
    fprintf(file, "   visual   x  bf  lv rg d st ge ge  r  g  b a  ax dp st   accum buffs    ms \n");
580
    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");
581
    fprintf(file, "-----------------------------------------------------------------------------\n");
582
  }
583
  else /* verbose */
584
  {
585
    fprintf(file, "\n");
586
    /* loop through all the pixel formats */
587
    for(i = 1; i <= maxpf; i++)
588
    {	    
589
      DescribePixelFormat(ctx->dc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
590
      /* only describe this format if it supports OpenGL */
591
      if(!(pfd.dwFlags & PFD_SUPPORT_OPENGL)
592
	 || (drawableonly && !(pfd.dwFlags & PFD_DRAW_TO_WINDOW))) continue;
593
      fprintf(file, "Visual ID: %2d  depth=%d  class=%s\n", i, pfd.cDepthBits, 
594
	     pfd.cColorBits <= 8 ? "PseudoColor" : "TrueColor");
595
      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);
596
      fprintf(file, "    generic=%d generic accelerated=%d\n", (pfd.dwFlags & PFD_GENERIC_FORMAT) == PFD_GENERIC_FORMAT, (pfd.dwFlags & PFD_GENERIC_ACCELERATED) == PFD_GENERIC_ACCELERATED);
597
      fprintf(file, "    rgba: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cRedBits, pfd.cGreenBits, pfd.cBlueBits, pfd.cAlphaBits);
598
      fprintf(file, "    auxBuffers=%d depthSize=%d stencilSize=%d\n", pfd.cAuxBuffers, pfd.cDepthBits, pfd.cStencilBits);
599
      fprintf(file, "    accum: redSize=%d greenSize=%d blueSize=%d alphaSize=%d\n", pfd.cAccumRedBits, pfd.cAccumGreenBits, pfd.cAccumBlueBits, pfd.cAccumAlphaBits);
600
      fprintf(file, "    multiSample=%d multisampleBuffers=%d\n", 0, 0);
601
      fprintf(file, "    Opaque.\n");
602
    }
603
  }
604
}
605

606
void
607
VisualInfo (GLContext* ctx)
608
{
609
  if (WGLEW_ARB_pixel_format)
610
    VisualInfoARB(ctx);
611
  else
612
    VisualInfoGDI(ctx);
613
}
614

615
/* ---------------------------------------------------------------------- */
616

617
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
618

619
void
620
VisualInfo (__attribute__((unused)) GLContext* ctx)
621
{
622
/*
623
  int attrib[] = { AGL_RGBA, AGL_NONE };
624
  AGLPixelFormat pf;
625
  GLint value;
626
  pf = aglChoosePixelFormat(NULL, 0, attrib);
627
  while (pf != NULL)
628
  {
629
    aglDescribePixelFormat(pf, GL_RGBA, &value);
630
    fprintf(stderr, "%d\n", value);
631
    pf = aglNextPixelFormat(pf);
632
  }
633
*/
634
}
635

636
/* ---------------------------------------------------------------------- */
637

638
#elif defined(__HAIKU__)
639

640
void
641
VisualInfo (GLContext* ctx)
642
{
643
  /* TODO */
644
}
645

646
#else /* GLX */
647

648
void
649
VisualInfo (GLContext* ctx)
650
{
651
  int n_fbc;
652
  GLXFBConfig* fbc;
653
  int value, ret, i;
654

655
  fbc = glXGetFBConfigs(ctx->dpy, DefaultScreen(ctx->dpy), &n_fbc);
656

657
  if (fbc)
658
  {
659
    if (!verbose)
660
    {
661
      /* print table header */
662
      fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
663
      fprintf(file, " |     |        visual           |      color      | ax dp st |    accum    |   ms  |  cav |\n");
664
      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");
665
      fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
666
      /* loop through all the fbcs */
667
      for (i=0; i<n_fbc; i++)
668
      {
669
        /* print out the information for this fbc */
670
        /* visual id */
671
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_FBCONFIG_ID, &value);
672
        if (ret != Success)
673
        {
674
          fprintf(file, "|  ?  |");
675
        }
676
        else
677
        {
678
          fprintf(file, " |% 4d | ", value);
679
        }
680
        /* visual type */
681
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DRAWABLE_TYPE, &value);
682
        if (ret != Success)
683
        {
684
          fprintf(file, " ? ");
685
        }
686
        else
687
        {
688
          if (value & GLX_WINDOW_BIT)
689
          {
690
            if (value & GLX_PBUFFER_BIT)
691
            {
692
              fprintf(file, "wp ");
693
            }
694
            else
695
            {
696
              fprintf(file, "wn ");
697
            }
698
          }
699
          else
700
          {
701
            if (value & GLX_PBUFFER_BIT)
702
            {
703
              fprintf(file, "pb ");
704
            }
705
            else if (value & GLX_PIXMAP_BIT)
706
            {
707
              fprintf(file, "pm ");
708
            }
709
            else
710
            {
711
              fprintf(file, " ? ");
712
            }
713
          }
714
        }
715
        /* x renderable */
716
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_X_RENDERABLE, &value);
717
        if (ret != Success)
718
        {
719
          fprintf(file, " ? ");
720
        }
721
        else
722
        {
723
          fprintf(file, value ? " y " : " n ");
724
        }
725
        /* class */
726
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_X_VISUAL_TYPE, &value);
727
        if (ret != Success)
728
        {
729
          fprintf(file, " ? ");
730
        }
731
        else
732
        {
733
          if (GLX_TRUE_COLOR == value)
734
            fprintf(file, "tc ");
735
          else if (GLX_DIRECT_COLOR == value)
736
            fprintf(file, "dc ");
737
          else if (GLX_PSEUDO_COLOR == value)
738
            fprintf(file, "pc ");
739
          else if (GLX_STATIC_COLOR == value)
740
            fprintf(file, "sc ");
741
          else if (GLX_GRAY_SCALE == value)
742
            fprintf(file, "gs ");
743
          else if (GLX_STATIC_GRAY == value)
744
            fprintf(file, "sg ");
745
          else if (GLX_X_VISUAL_TYPE == value)
746
            fprintf(file, " . ");
747
          else
748
            fprintf(file, " ? ");
749
        }
750
        /* format */
751
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_RENDER_TYPE, &value);
752
        if (ret != Success)
753
        {
754
          fprintf(file, " ? ");
755
        }
756
        else
757
        {
758
          if (GLXEW_NV_float_buffer)
759
          {
760
            int ret2, value2;
761
            ret2 = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_FLOAT_COMPONENTS_NV, &value2);
762
            if (Success == ret2 && GL_TRUE == value2)
763
            {
764
              fprintf(file, " f ");
765
            }
766
            else if (value & GLX_RGBA_BIT)
767
              fprintf(file, " i ");
768
            else if (value & GLX_COLOR_INDEX_BIT)
769
              fprintf(file, " c ");
770
            else
771
              fprintf(file, " ? ");
772
          }
773
          else
774
          {
775
            if (value & GLX_RGBA_FLOAT_ATI_BIT)
776
              fprintf(file, " f ");
777
            else if (value & GLX_RGBA_BIT)
778
              fprintf(file, " i ");
779
            else if (value & GLX_COLOR_INDEX_BIT)
780
              fprintf(file, " c ");
781
            else
782
              fprintf(file, " ? ");
783
          }
784
        }
785
        /* double buffer */
786
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DOUBLEBUFFER, &value);
787
        fprintf(file, " %c ", Success != ret ? '?' : (value ? 'y' : '.'));
788
        /* stereo */
789
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_STEREO, &value);
790
        fprintf(file, " %c ", Success != ret ? '?' : (value ? 'y' : '.'));
791
        /* level */
792
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_LEVEL, &value);
793
        if (Success != ret)
794
        {
795
          fprintf(file, " ? ");
796
        }
797
        else
798
        {
799
          fprintf(file, "%2d ", value);
800
        }
801
        /* transparency */
802
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_TRANSPARENT_TYPE, &value);
803
        if (Success != ret)
804
        {
805
          fprintf(file, " ? | ");
806
        }
807
        else
808
        {
809
          if (GLX_TRANSPARENT_RGB == value)
810
            fprintf(file, " r | ");
811
          else if (GLX_TRANSPARENT_INDEX == value)
812
            fprintf(file, " i | ");
813
          else if (GLX_NONE == value)
814
            fprintf(file, " . | ");
815
          else
816
            fprintf(file, " ? | ");
817
        }
818
        /* color size */
819
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_BUFFER_SIZE, &value);
820
        if (Success != ret)
821
        {
822
          fprintf(file, "  ? ");
823
        }
824
        else
825
        {
826
          if (value)
827
            fprintf(file, "%3d ", value);
828
          else
829
            fprintf(file, "  . ");
830
        }
831
        /* red size */
832
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_RED_SIZE, &value);
833
        if (Success != ret)
834
        {
835
          fprintf(file, " ? ");
836
        }
837
        else
838
        {
839
          if (value)
840
            fprintf(file, "%2d ", value);
841
          else
842
            fprintf(file, " . ");
843
        }
844
        /* green size */
845
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_GREEN_SIZE, &value);
846
        if (Success != ret)
847
        {
848
          fprintf(file, " ? ");
849
        }
850
        else
851
        {
852
          if (value)
853
            fprintf(file, "%2d ", value);
854
          else
855
            fprintf(file, " . ");
856
        }
857
        /* blue size */
858
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_BLUE_SIZE, &value);
859
        if (Success != ret)
860
        {
861
          fprintf(file, " ? ");
862
        }
863
        else
864
        {
865
          if (value)
866
            fprintf(file, "%2d ", value);
867
          else
868
            fprintf(file, " . ");
869
        }
870
        /* alpha size */
871
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ALPHA_SIZE, &value);
872
        if (Success != ret)
873
        {
874
          fprintf(file, " ? | ");
875
        }
876
        else
877
        {
878
          if (value)
879
            fprintf(file, "%2d | ", value);
880
          else
881
            fprintf(file, " . | ");
882
        }
883
        /* aux buffers */
884
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_AUX_BUFFERS, &value);
885
        if (Success != ret)
886
        {
887
          fprintf(file, " ? ");
888
        }
889
        else
890
        {
891
          if (value)
892
            fprintf(file, "%2d ", value);
893
          else
894
            fprintf(file, " . ");
895
        }
896
        /* depth size */
897
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_DEPTH_SIZE, &value);
898
        if (Success != ret)
899
        {
900
          fprintf(file, " ? ");
901
        }
902
        else
903
        {
904
          if (value)
905
            fprintf(file, "%2d ", value);
906
          else
907
            fprintf(file, " . ");
908
        }
909
        /* stencil size */
910
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_STENCIL_SIZE, &value);
911
        if (Success != ret)
912
        {
913
          fprintf(file, " ? | ");
914
        }
915
        else
916
        {
917
          if (value)
918
            fprintf(file, "%2d | ", value);
919
          else
920
            fprintf(file, " . | ");
921
        }
922
        /* accum red size */
923
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_RED_SIZE, &value);
924
        if (Success != ret)
925
        {
926
          fprintf(file, " ? ");
927
        }
928
        else
929
        {
930
          if (value)
931
            fprintf(file, "%2d ", value);
932
          else
933
            fprintf(file, " . ");
934
        }
935
        /* accum green size */
936
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_GREEN_SIZE, &value);
937
        if (Success != ret)
938
        {
939
          fprintf(file, " ? ");
940
        }
941
        else
942
        {
943
          if (value)
944
            fprintf(file, "%2d ", value);
945
          else
946
            fprintf(file, " . ");
947
        }
948
        /* accum blue size */
949
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_BLUE_SIZE, &value);
950
        if (Success != ret)
951
        {
952
          fprintf(file, " ? ");
953
        }
954
        else
955
        {
956
          if (value)
957
            fprintf(file, "%2d ", value);
958
          else
959
            fprintf(file, " . ");
960
        }
961
        /* accum alpha size */
962
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_ACCUM_ALPHA_SIZE, &value);
963
        if (Success != ret)
964
        {
965
          fprintf(file, " ? | ");
966
        }
967
        else
968
        {
969
          if (value)
970
            fprintf(file, "%2d | ", value);
971
          else
972
            fprintf(file, " . | ");
973
        }
974
        /* multisample */
975
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_SAMPLES, &value);
976
        if (Success != ret)
977
        {
978
          fprintf(file, " ? ");
979
        }
980
        else
981
        {
982
          fprintf(file, "%2d ", value);
983
        }
984
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_SAMPLE_BUFFERS, &value);
985
        if (Success != ret)
986
        {
987
          fprintf(file, " ? | ");
988
        }
989
        else
990
        {
991
          fprintf(file, "%2d | ", value);
992
        }
993
        /* caveat */
994
        ret = glXGetFBConfigAttrib(ctx->dpy, fbc[i], GLX_CONFIG_CAVEAT, &value);
995
        if (Success != ret)
996
        {
997
          fprintf(file, "???? |");
998
        }
999
        else
1000
        {
1001
          if (GLX_NONE == value)
1002
            fprintf(file, "none |\n");
1003
          else if (GLX_SLOW_CONFIG == value)
1004
            fprintf(file, "slow |\n");
1005
          else if (GLX_NON_CONFORMANT_CONFIG == value)
1006
            fprintf(file, "ncft |\n");
1007
          else
1008
            fprintf(file, "???? |\n");
1009
        }
1010
      }
1011
      /* print table footer */
1012
      fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
1013
      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");
1014
      fprintf(file, " |     |        visual           |      color      | ax dp st |    accum    |   ms  |  cav |\n");
1015
      fprintf(file, " +-----+-------------------------+-----------------+----------+-------------+-------+------+\n");
1016
    }
1017
  }
1018
}
1019

1020
#endif
1021

1022
/* ------------------------------------------------------------------------ */
1023

1024
#if defined(GLEW_OSMESA)
1025
void InitContext (GLContext* ctx)
1026
{
1027
  ctx->ctx = NULL;
1028
}
1029

1030
static const GLint osmFormat = GL_UNSIGNED_BYTE;
1031
static const GLint osmWidth = 640;
1032
static const GLint osmHeight = 480;
1033
static GLubyte *osmPixels = NULL;
1034

1035
GLboolean CreateContext (GLContext* ctx)
1036
{
1037
  if (NULL == ctx) return GL_TRUE;
1038
  ctx->ctx = OSMesaCreateContext(OSMESA_RGBA, NULL);
1039
  if (NULL == ctx->ctx) return GL_TRUE;
1040
  if (NULL == osmPixels)
1041
  {
1042
    osmPixels = (GLubyte *) calloc(osmWidth*osmHeight*4, 1);
1043
  }
1044
  if (!OSMesaMakeCurrent(ctx->ctx, osmPixels, GL_UNSIGNED_BYTE, osmWidth, osmHeight))
1045
  {
1046
      return GL_TRUE;
1047
  }
1048
  return GL_FALSE;
1049
}
1050

1051
void DestroyContext (GLContext* ctx)
1052
{
1053
  if (NULL == ctx) return;
1054
  if (NULL != ctx->ctx) OSMesaDestroyContext(ctx->ctx);
1055
}
1056
/* ------------------------------------------------------------------------ */
1057

1058
#elif defined(GLEW_EGL)
1059
void InitContext (GLContext* ctx)
1060
{
1061
  ctx->ctx = NULL;
1062
}
1063

1064
GLboolean CreateContext (GLContext* ctx)
1065
{
1066
  return GL_FALSE;
1067
}
1068

1069
void DestroyContext (GLContext* ctx)
1070
{
1071
  if (NULL == ctx) return;
1072
  return;
1073
}
1074

1075
/* ------------------------------------------------------------------------ */
1076

1077
#elif defined(_WIN32)
1078

1079
void InitContext (GLContext* ctx)
1080
{
1081
  ctx->wnd = NULL;
1082
  ctx->dc = NULL;
1083
  ctx->rc = NULL;
1084
}
1085

1086
GLboolean CreateContext (GLContext* ctx)
1087
{
1088
  WNDCLASS wc;
1089
  PIXELFORMATDESCRIPTOR pfd;
1090
  /* check for input */
1091
  if (NULL == ctx) return GL_TRUE;
1092
  /* register window class */
1093
  ZeroMemory(&wc, sizeof(WNDCLASS));
1094
  wc.hInstance = GetModuleHandle(NULL);
1095
  wc.lpfnWndProc = DefWindowProc;
1096
  wc.lpszClassName = "GLEW";
1097
  if (0 == RegisterClass(&wc)) return GL_TRUE;
1098
  /* create window */
1099
  ctx->wnd = CreateWindow("GLEW", "GLEW", 0, CW_USEDEFAULT, CW_USEDEFAULT, 
1100
                          CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, 
1101
                          GetModuleHandle(NULL), NULL);
1102
  if (NULL == ctx->wnd) return GL_TRUE;
1103
  /* get the device context */
1104
  ctx->dc = GetDC(ctx->wnd);
1105
  if (NULL == ctx->dc) return GL_TRUE;
1106
  /* find pixel format */
1107
  ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));
1108
  if (visual == -1) /* find default */
1109
  {
1110
    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
1111
    pfd.nVersion = 1;
1112
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
1113
    visual = ChoosePixelFormat(ctx->dc, &pfd);
1114
    if (0 == visual) return GL_TRUE;
1115
  }
1116
  /* set the pixel format for the dc */
1117
  if (FALSE == SetPixelFormat(ctx->dc, visual, &pfd)) return GL_TRUE;
1118
  /* create rendering context */
1119
  ctx->rc = wglCreateContext(ctx->dc);
1120
  if (NULL == ctx->rc) return GL_TRUE;
1121
  if (FALSE == wglMakeCurrent(ctx->dc, ctx->rc)) return GL_TRUE;
1122
  return GL_FALSE;
1123
}
1124

1125
void DestroyContext (GLContext* ctx)
1126
{
1127
  if (NULL == ctx) return;
1128
  if (NULL != ctx->rc) wglMakeCurrent(NULL, NULL);
1129
  if (NULL != ctx->rc) wglDeleteContext(wglGetCurrentContext());
1130
  if (NULL != ctx->wnd && NULL != ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
1131
  if (NULL != ctx->wnd) DestroyWindow(ctx->wnd);
1132
  UnregisterClass("GLEW", GetModuleHandle(NULL));
1133
}
1134

1135
/* ------------------------------------------------------------------------ */
1136

1137
#elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX)
1138

1139
void InitContext (GLContext* ctx)
1140
{
1141
  ctx->ctx = NULL;
1142
  ctx->octx = NULL;
1143
}
1144

1145
GLboolean CreateContext (GLContext* ctx)
1146
{
1147
  CGLPixelFormatAttribute attrib[] = { kCGLPFAAccelerated, 0 };
1148
  CGLPixelFormatObj pf;
1149
  GLint npix;
1150
  CGLError error;
1151
  /* check input */
1152
  if (NULL == ctx) return GL_TRUE;
1153
  error = CGLChoosePixelFormat(attrib, &pf, &npix);
1154
  if (error) return GL_TRUE;
1155
  error = CGLCreateContext(pf, NULL, &ctx->ctx);
1156
  if (error) return GL_TRUE;
1157
  CGLReleasePixelFormat(pf);
1158
  ctx->octx = CGLGetCurrentContext();
1159
  error = CGLSetCurrentContext(ctx->ctx);
1160
  if (error) return GL_TRUE;
1161
  return GL_FALSE;
1162
}
1163

1164
void DestroyContext (GLContext* ctx)
1165
{
1166
  if (NULL == ctx) return;
1167
  CGLSetCurrentContext(ctx->octx);
1168
  if (NULL != ctx->ctx) CGLReleaseContext(ctx->ctx);
1169
}
1170

1171
/* ------------------------------------------------------------------------ */
1172

1173
#elif defined(__HAIKU__)
1174

1175
void
1176
InitContext (GLContext* ctx)
1177
{
1178
  /* TODO */
1179
}
1180

1181
GLboolean
1182
CreateContext (GLContext* ctx)
1183
{
1184
  /* TODO */
1185
  return GL_FALSE;
1186
}
1187

1188
void
1189
DestroyContext (GLContext* ctx)
1190
{
1191
  /* TODO */
1192
}
1193

1194
/* ------------------------------------------------------------------------ */
1195

1196
#else /* __UNIX || (__APPLE__ && GLEW_APPLE_GLX) */
1197

1198
void InitContext (GLContext* ctx)
1199
{
1200
  ctx->dpy = NULL;
1201
  ctx->vi = NULL;
1202
  ctx->ctx = NULL;
1203
  ctx->wnd = 0;
1204
  ctx->cmap = 0;
1205
}
1206

1207
GLboolean CreateContext (GLContext* ctx)
1208
{
1209
  int attrib[] = { GLX_RGBA, GLX_DOUBLEBUFFER, None };
1210
  int erb, evb;
1211
  XSetWindowAttributes swa;
1212
  /* check input */
1213
  if (NULL == ctx) return GL_TRUE;
1214
  /* open display */
1215
  ctx->dpy = XOpenDisplay(display);
1216
  if (NULL == ctx->dpy) return GL_TRUE;
1217
  /* query for glx */
1218
  if (!glXQueryExtension(ctx->dpy, &erb, &evb)) return GL_TRUE;
1219
  /* choose visual */
1220
  ctx->vi = glXChooseVisual(ctx->dpy, DefaultScreen(ctx->dpy), attrib);
1221
  if (NULL == ctx->vi) return GL_TRUE;
1222
  /* create context */
1223
  ctx->ctx = glXCreateContext(ctx->dpy, ctx->vi, None, True);
1224
  if (NULL == ctx->ctx) return GL_TRUE;
1225
  /* create window */
1226
  /*wnd = XCreateSimpleWindow(dpy, RootWindow(dpy, vi->screen), 0, 0, 1, 1, 1, 0, 0);*/
1227
  ctx->cmap = XCreateColormap(ctx->dpy, RootWindow(ctx->dpy, ctx->vi->screen),
1228
                              ctx->vi->visual, AllocNone);
1229
  swa.border_pixel = 0;
1230
  swa.colormap = ctx->cmap;
1231
  ctx->wnd = XCreateWindow(ctx->dpy, RootWindow(ctx->dpy, ctx->vi->screen), 
1232
                           0, 0, 1, 1, 0, ctx->vi->depth, InputOutput, ctx->vi->visual, 
1233
                           CWBorderPixel | CWColormap, &swa);
1234
  /* make context current */
1235
  if (!glXMakeCurrent(ctx->dpy, ctx->wnd, ctx->ctx)) return GL_TRUE;
1236
  return GL_FALSE;
1237
}
1238

1239
void DestroyContext (GLContext* ctx)
1240
{
1241
  if (NULL != ctx->dpy && NULL != ctx->ctx) glXDestroyContext(ctx->dpy, ctx->ctx);
1242
  if (NULL != ctx->dpy && 0 != ctx->wnd) XDestroyWindow(ctx->dpy, ctx->wnd);
1243
  if (NULL != ctx->dpy && 0 != ctx->cmap) XFreeColormap(ctx->dpy, ctx->cmap);
1244
  if (NULL != ctx->vi) XFree(ctx->vi);
1245
  if (NULL != ctx->dpy) XCloseDisplay(ctx->dpy);
1246
}
1247

1248
#endif /* __UNIX || (__APPLE__ && GLEW_APPLE_GLX) */
1249

1250
GLboolean ParseArgs (int argc, char** argv)
1251
{
1252
  int p = 0;
1253
  while (p < argc)
1254
  {
1255
#if defined(_WIN32)
1256
    if (!strcmp(argv[p], "-pf") || !strcmp(argv[p], "-pixelformat"))
1257
    {
1258
      if (++p >= argc) return GL_TRUE;
1259
      display = NULL;
1260
      visual = strtol(argv[p], NULL, 0);
1261
    }
1262
    else if (!strcmp(argv[p], "-a"))
1263
    {
1264
      showall = 1;
1265
    }
1266
    else if (!strcmp(argv[p], "-s"))
1267
    {
1268
      displaystdout = 1;
1269
    }
1270
    else if (!strcmp(argv[p], "-h"))
1271
    {
1272
      return GL_TRUE;
1273
    }
1274
    else
1275
      return GL_TRUE;
1276
#else
1277
    if (!strcmp(argv[p], "-display"))
1278
    {
1279
      if (++p >= argc) return GL_TRUE;
1280
      display = argv[p];
1281
    }
1282
    else if (!strcmp(argv[p], "-visual"))
1283
    {
1284
      if (++p >= argc) return GL_TRUE;
1285
      visual = (int)strtol(argv[p], NULL, 0);
1286
    }
1287
    else if (!strcmp(argv[p], "-h"))
1288
    {
1289
      return GL_TRUE;
1290
    }
1291
    else
1292
      return GL_TRUE;
1293
#endif
1294
    p++;
1295
  }
1296
  return GL_FALSE;
1297
}
1298

1299
CoCalc provides the best real-time collaborative environment for Jupyter Notebooks, LaTeX documents, and SageMath, scalable from individual users to large groups and classes!

Product

Resources

Company
