progs/xdemos/glxswapcontrol.c

   1 /*
   2  * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included
  12  * in all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  18  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  19  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20  */
  21
  22 /*
  23  * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT)
  24  * Port by Brian Paul  23 March 2001
  25  *
  26  * Modified by Ian Romanick <idr@us.ibm.com> 09 April 2003 to support
  27  * GLX_{MESA,SGI}_swap_control and GLX_OML_sync_control.
  28  *
  29  * Command line options:
  30  *    -display       Name of the display to use.
  31  *    -info          print GL implementation information
  32  *    -swap N        Attempt to set the swap interval to 1/N second
  33  *    -forcegetrate  Get the display refresh rate even if the required GLX
  34  *                   extension is not supported.
  35  */
  36
  37
  38 #include <math.h>
  39 #include <stdlib.h>
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <X11/Xlib.h>
  43 #include <X11/keysym.h>
  44 #ifndef __VMS
  45 /*# include <stdint.h>*/
  46 #endif
  47 # define GLX_GLXEXT_PROTOTYPES
  48 #include <GL/gl.h>
  49 #include <GL/glx.h>
  50
  51 #ifndef GLX_MESA_swap_control
  52 typedef GLint ( * PFNGLXSWAPINTERVALMESAPROC) (unsigned interval);
  53 typedef GLint ( * PFNGLXGETSWAPINTERVALMESAPROC) ( void );
  54 #endif
  55
  56 #if !defined( GLX_OML_sync_control ) && defined( _STDINT_H )
  57 #define GLX_OML_sync_control 1
  58 typedef Bool ( * PFNGLXGETMSCRATEOMLPROC) (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator);
  59 #endif
  60
  61 #ifndef GLX_MESA_swap_frame_usage
  62 #define GLX_MESA_swap_frame_usage 1
  63 typedef int ( * PFNGLXGETFRAMEUSAGEMESAPROC) (Display *dpy, GLXDrawable drawable, float * usage );
  64 #endif
  65
  66 #define BENCHMARK
  67
  68 PFNGLXGETFRAMEUSAGEMESAPROC get_frame_usage = NULL;
  69
  70 #ifdef BENCHMARK
  71
  72 /* XXX this probably isn't very portable */
  73
  74 #include <sys/time.h>
  75 #include <unistd.h>
  76
  77 #define NUL '\0'
  78
  79 /* return current time (in seconds) */
  80 static int
  81 current_time(void)
  82 {
  83    struct timeval tv;
  84 #ifdef __VMS
  85    (void) gettimeofday(&tv, NULL );
  86 #else
  87    struct timezone tz;
  88    (void) gettimeofday(&tv, &tz);
  89 #endif
  90    return (int) tv.tv_sec;
  91 }
  92
  93 #else /*BENCHMARK*/
  94
  95 /* dummy */
  96 static int
  97 current_time(void)
  98 {
  99    return 0;
 100 }
 101
 102 #endif /*BENCHMARK*/
 103
 104
 105
 106 #ifndef M_PI
 107 #define M_PI 3.14159265
 108 #endif
 109
 110
 111 static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
 112 static GLint gear1, gear2, gear3;
 113 static GLfloat angle = 0.0;
 114
 115 static GLboolean has_OML_sync_control = GL_FALSE;
 116 static GLboolean has_SGI_swap_control = GL_FALSE;
 117 static GLboolean has_MESA_swap_control = GL_FALSE;
 118 static GLboolean has_MESA_swap_frame_usage = GL_FALSE;
 119
 120 static char ** extension_table = NULL;
 121 static unsigned num_extensions;
 122
 123 static GLboolean use_ztrick = GL_FALSE;
 124 static GLfloat   aspect;
 125
 126 /*
 127  *
 128  *  Draw a gear wheel.  You'll probably want to call this function when
 129  *  building a display list since we do a lot of trig here.
 130  *
 131  *  Input:  inner_radius - radius of hole at center
 132  *          outer_radius - radius at center of teeth
 133  *          width - width of gear
 134  *          teeth - number of teeth
 135  *          tooth_depth - depth of tooth
 136  */
 137 static void
 138 gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
 139      GLint teeth, GLfloat tooth_depth)
 140 {
 141    GLint i;
 142    GLfloat r0, r1, r2;
 143    GLfloat angle, da;
 144    GLfloat u, v, len;
 145
 146    r0 = inner_radius;
 147    r1 = outer_radius - tooth_depth / 2.0;
 148    r2 = outer_radius + tooth_depth / 2.0;
 149
 150    da = 2.0 * M_PI / teeth / 4.0;
 151
 152    glShadeModel(GL_FLAT);
 153
 154    glNormal3f(0.0, 0.0, 1.0);
 155
 156    /* draw front face */
 157    glBegin(GL_QUAD_STRIP);
 158    for (i = 0; i <= teeth; i++) {
 159       angle = i * 2.0 * M_PI / teeth;
 160       glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
 161       glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
 162       if (i < teeth) {
 163          glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
 164          glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
 165                     width * 0.5);
 166       }
 167    }
 168    glEnd();
 169
 170    /* draw front sides of teeth */
 171    glBegin(GL_QUADS);
 172    da = 2.0 * M_PI / teeth / 4.0;
 173    for (i = 0; i < teeth; i++) {
 174       angle = i * 2.0 * M_PI / teeth;
 175
 176       glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
 177       glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
 178       glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
 179                  width * 0.5);
 180       glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
 181                  width * 0.5);
 182    }
 183    glEnd();
 184
 185    glNormal3f(0.0, 0.0, -1.0);
 186
 187    /* draw back face */
 188    glBegin(GL_QUAD_STRIP);
 189    for (i = 0; i <= teeth; i++) {
 190       angle = i * 2.0 * M_PI / teeth;
 191       glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
 192       glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
 193       if (i < teeth) {
 194          glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
 195                     -width * 0.5);
 196          glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
 197       }
 198    }
 199    glEnd();
 200
 201    /* draw back sides of teeth */
 202    glBegin(GL_QUADS);
 203    da = 2.0 * M_PI / teeth / 4.0;
 204    for (i = 0; i < teeth; i++) {
 205       angle = i * 2.0 * M_PI / teeth;
 206
 207       glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
 208                  -width * 0.5);
 209       glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
 210                  -width * 0.5);
 211       glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
 212       glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
 213    }
 214    glEnd();
 215
 216    /* draw outward faces of teeth */
 217    glBegin(GL_QUAD_STRIP);
 218    for (i = 0; i < teeth; i++) {
 219       angle = i * 2.0 * M_PI / teeth;
 220
 221       glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
 222       glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
 223       u = r2 * cos(angle + da) - r1 * cos(angle);
 224       v = r2 * sin(angle + da) - r1 * sin(angle);
 225       len = sqrt(u * u + v * v);
 226       u /= len;
 227       v /= len;
 228       glNormal3f(v, -u, 0.0);
 229       glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
 230       glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
 231       glNormal3f(cos(angle), sin(angle), 0.0);
 232       glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
 233                  width * 0.5);
 234       glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da),
 235                  -width * 0.5);
 236       u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
 237       v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
 238       glNormal3f(v, -u, 0.0);
 239       glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
 240                  width * 0.5);
 241       glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),
 242                  -width * 0.5);
 243       glNormal3f(cos(angle), sin(angle), 0.0);
 244    }
 245
 246    glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
 247    glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
 248
 249    glEnd();
 250
 251    glShadeModel(GL_SMOOTH);
 252
 253    /* draw inside radius cylinder */
 254    glBegin(GL_QUAD_STRIP);
 255    for (i = 0; i <= teeth; i++) {
 256       angle = i * 2.0 * M_PI / teeth;
 257       glNormal3f(-cos(angle), -sin(angle), 0.0);
 258       glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
 259       glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
 260    }
 261    glEnd();
 262 }
 263
 264
 265 static void
 266 draw(void)
 267 {
 268    if ( use_ztrick ) {
 269       static GLboolean flip = GL_FALSE;
 270       static const GLfloat vert[4][3] = {
 271          { -1, -1, -0.999 },
 272          {  1, -1, -0.999 },
 273          {  1,  1, -0.999 },
 274          { -1,  1, -0.999 }
 275       };
 276       static const GLfloat col[4][3] = {
 277          { 1.0, 0.6, 0.0 },
 278          { 1.0, 0.6, 0.0 },
 279          { 0.0, 0.0, 0.0 },
 280          { 0.0, 0.0, 0.0 },
 281       };
 282
 283       if ( flip ) {
 284          glDepthRange(0, 0.5);
 285          glDepthFunc(GL_LEQUAL);
 286       }
 287       else {
 288          glDepthRange(1.0, 0.4999);
 289          glDepthFunc(GL_GEQUAL);
 290       }
 291
 292       flip = !flip;
 293
 294       /* The famous Quake "Z trick" only works when the whole screen is
 295        * re-drawn each frame.
 296        */
 297
 298       glMatrixMode(GL_MODELVIEW);
 299       glLoadIdentity();
 300       glMatrixMode(GL_PROJECTION);
 301       glLoadIdentity();
 302       glOrtho(-1, 1, -1, 1, -1, 1);
 303       glDisable(GL_LIGHTING);
 304       glShadeModel(GL_SMOOTH);
 305
 306       glEnable( GL_VERTEX_ARRAY );
 307       glEnable( GL_COLOR_ARRAY );
 308       glVertexPointer( 3, GL_FLOAT, 0, vert );
 309       glColorPointer( 3, GL_FLOAT, 0, col );
 310       glDrawArrays( GL_POLYGON, 0, 4 );
 311       glDisable( GL_COLOR_ARRAY );
 312       glDisable( GL_VERTEX_ARRAY );
 313
 314       glMatrixMode(GL_PROJECTION);
 315       glLoadIdentity();
 316       glFrustum(-1.0, 1.0, -aspect, aspect, 5.0, 60.0);
 317
 318       glEnable(GL_LIGHTING);
 319
 320       glMatrixMode(GL_MODELVIEW);
 321       glLoadIdentity();
 322       glTranslatef(0.0, 0.0, -40.0);
 323    }
 324    else {
 325       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 326    }
 327
 328    glPushMatrix();
 329    glRotatef(view_rotx, 1.0, 0.0, 0.0);
 330    glRotatef(view_roty, 0.0, 1.0, 0.0);
 331    glRotatef(view_rotz, 0.0, 0.0, 1.0);
 332
 333    glPushMatrix();
 334    glTranslatef(-3.0, -2.0, 0.0);
 335    glRotatef(angle, 0.0, 0.0, 1.0);
 336    glCallList(gear1);
 337    glPopMatrix();
 338
 339    glPushMatrix();
 340    glTranslatef(3.1, -2.0, 0.0);
 341    glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
 342    glCallList(gear2);
 343    glPopMatrix();
 344
 345    glPushMatrix();
 346    glTranslatef(-3.1, 4.2, 0.0);
 347    glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
 348    glCallList(gear3);
 349    glPopMatrix();
 350
 351    glPopMatrix();
 352 }
 353
 354
 355 /* new window size or exposure */
 356 static void
 357 reshape(int width, int height)
 358 {
 359    aspect = (GLfloat) height / (GLfloat) width;
 360
 361
 362    glViewport(0, 0, (GLint) width, (GLint) height);
 363    glMatrixMode(GL_PROJECTION);
 364    glLoadIdentity();
 365
 366    glFrustum(-1.0, 1.0, -aspect, aspect, 5.0, 60.0);
 367    glMatrixMode(GL_MODELVIEW);
 368    glLoadIdentity();
 369    glTranslatef(0.0, 0.0, -40.0);
 370 }
 371
 372
 373 static void
 374 init(void)
 375 {
 376    static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 };
 377    static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 };
 378    static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 };
 379    static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 };
 380
 381    glLightfv(GL_LIGHT0, GL_POSITION, pos);
 382    glEnable(GL_CULL_FACE);
 383    glEnable(GL_LIGHTING);
 384    glEnable(GL_LIGHT0);
 385    glEnable(GL_DEPTH_TEST);
 386
 387    /* make the gears */
 388    gear1 = glGenLists(1);
 389    glNewList(gear1, GL_COMPILE);
 390    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red);
 391    gear(1.0, 4.0, 1.0, 20, 0.7);
 392    glEndList();
 393
 394    gear2 = glGenLists(1);
 395    glNewList(gear2, GL_COMPILE);
 396    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green);
 397    gear(0.5, 2.0, 2.0, 10, 0.7);
 398    glEndList();
 399
 400    gear3 = glGenLists(1);
 401    glNewList(gear3, GL_COMPILE);
 402    glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
 403    gear(1.3, 2.0, 0.5, 10, 0.7);
 404    glEndList();
 405
 406    glEnable(GL_NORMALIZE);
 407 }
 408
 409
 410 /*
 411  * Create an RGB, double-buffered window.
 412  * Return the window and context handles.
 413  */
 414 static void
 415 make_window( Display *dpy, const char *name,
 416              int x, int y, int width, int height,
 417              Window *winRet, GLXContext *ctxRet)
 418 {
 419    int attrib[] = { GLX_RGBA,
 420                     GLX_RED_SIZE, 1,
 421                     GLX_GREEN_SIZE, 1,
 422                     GLX_BLUE_SIZE, 1,
 423                     GLX_DOUBLEBUFFER,
 424                     GLX_DEPTH_SIZE, 1,
 425                     None };
 426    int scrnum;
 427    XSetWindowAttributes attr;
 428    unsigned long mask;
 429    Window root;
 430    Window win;
 431    GLXContext ctx;
 432    XVisualInfo *visinfo;
 433
 434    scrnum = DefaultScreen( dpy );
 435    root = RootWindow( dpy, scrnum );
 436
 437    visinfo = glXChooseVisual( dpy, scrnum, attrib );
 438    if (!visinfo) {
 439       printf("Error: couldn't get an RGB, Double-buffered visual\n");
 440       exit(1);
 441    }
 442
 443    /* window attributes */
 444    attr.background_pixel = 0;
 445    attr.border_pixel = 0;
 446    attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone);
 447    attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
 448    mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
 449
 450    win = XCreateWindow( dpy, root, 0, 0, width, height,
 451                         0, visinfo->depth, InputOutput,
 452                         visinfo->visual, mask, &attr );
 453
 454    /* set hints and properties */
 455    {
 456       XSizeHints sizehints;
 457       sizehints.x = x;
 458       sizehints.y = y;
 459       sizehints.width  = width;
 460       sizehints.height = height;
 461       sizehints.flags = USSize | USPosition;
 462       XSetNormalHints(dpy, win, &sizehints);
 463       XSetStandardProperties(dpy, win, name, name,
 464                               None, (char **)NULL, 0, &sizehints);
 465    }
 466
 467    ctx = glXCreateContext( dpy, visinfo, NULL, True );
 468    if (!ctx) {
 469       printf("Error: glXCreateContext failed\n");
 470       exit(1);
 471    }
 472
 473    XFree(visinfo);
 474
 475    *winRet = win;
 476    *ctxRet = ctx;
 477 }
 478
 479
 480 static void
 481 event_loop(Display *dpy, Window win)
 482 {
 483    float  frame_usage = 0.0;
 484
 485    while (1) {
 486       while (XPending(dpy) > 0) {
 487          XEvent event;
 488          XNextEvent(dpy, &event);
 489          switch (event.type) {
 490          case Expose:
 491             /* we'll redraw below */
 492             break;
 493          case ConfigureNotify:
 494             reshape(event.xconfigure.width, event.xconfigure.height);
 495             break;
 496          case KeyPress:
 497             {
 498                char buffer[10];
 499                int r, code;
 500                code = XLookupKeysym(&event.xkey, 0);
 501                if (code == XK_Left) {
 502                   view_roty += 5.0;
 503                }
 504                else if (code == XK_Right) {
 505                   view_roty -= 5.0;
 506                }
 507                else if (code == XK_Up) {
 508                   view_rotx += 5.0;
 509                }
 510                else if (code == XK_Down) {
 511                   view_rotx -= 5.0;
 512                }
 513                else {
 514                   r = XLookupString(&event.xkey, buffer, sizeof(buffer),
 515                                     NULL, NULL);
 516                   if (buffer[0] == 27) {
 517                      /* escape */
 518                      return;
 519                   }
 520                }
 521             }
 522          }
 523       }
 524
 525       /* next frame */
 526       angle += 2.0;
 527
 528       draw();
 529       if ( get_frame_usage != NULL ) {
 530          GLfloat   temp;
 531
 532          (*get_frame_usage)( dpy, win, & temp );
 533          frame_usage += temp;
 534       }
 535
 536       glXSwapBuffers(dpy, win);
 537
 538       /* calc framerate */
 539       {
 540          static int t0 = -1;
 541          static int frames = 0;
 542          int t = current_time();
 543
 544          if (t0 < 0)
 545             t0 = t;
 546
 547          frames++;
 548
 549          if (t - t0 >= 5.0) {
 550             GLfloat seconds = t - t0;
 551             GLfloat fps = frames / seconds;
 552             if ( get_frame_usage != NULL ) {
 553                printf("%d frames in %3.1f seconds = %6.3f FPS (%3.1f%% usage)\n",
 554                       frames, seconds, fps,
 555                       (frame_usage * 100.0) / (float) frames );
 556             }
 557             else {
 558                printf("%d frames in %3.1f seconds = %6.3f FPS\n",
 559                       frames, seconds, fps);
 560             }
 561
 562             t0 = t;
 563             frames = 0;
 564             frame_usage = 0.0;
 565          }
 566       }
 567    }
 568 }
 569
 570
 571 /**
 572  * Display the refresh rate of the display using the GLX_OML_sync_control
 573  * extension.
 574  */
 575
 576 static void
 577 show_refresh_rate( Display * dpy )
 578 {
 579 #if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
 580    PFNGLXGETMSCRATEOMLPROC  get_msc_rate;
 581    int32_t  n;
 582    int32_t  d;
 583
 584    get_msc_rate = (PFNGLXGETMSCRATEOMLPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetMscRateOML" );
 585    if ( get_msc_rate != NULL ) {
 586       (*get_msc_rate)( dpy, glXGetCurrentDrawable(), &n, &d );
 587       printf( "refresh rate: %.1fHz\n", (float) n / d );
 588       return;
 589    }
 590 #endif
 591    printf( "glXGetMscRateOML not supported.\n" );
 592 }
 593
 594
 595 /**
 596  * Fill in the table of extension strings from a supplied extensions string
 597  * (as returned by glXQueryExtensionsString).
 598  *
 599  * \param string   String of GLX extensions.
 600  * \sa is_extension_supported
 601  */
 602
 603 static void
 604 make_extension_table( const char * string )
 605 {
 606    char ** string_tab;
 607    unsigned  num_strings;
 608    unsigned  base;
 609    unsigned  idx;
 610    unsigned  i;
 611
 612    /* Count the number of spaces in the string.  That gives a base-line
 613     * figure for the number of extension in the string.
 614     */
 615
 616    num_strings = 1;
 617    for ( i = 0 ; string[i] != NUL ; i++ ) {
 618       if ( string[i] == ' ' ) {
 619          num_strings++;
 620       }
 621    }
 622
 623    string_tab = (char **) malloc( sizeof( char * ) * num_strings );
 624    if ( string_tab == NULL ) {
 625       return;
 626    }
 627
 628    base = 0;
 629    idx = 0;
 630
 631    while ( string[ base ] != NUL ) {
 632       /* Determine the length of the next extension string.
 633        */
 634
 635       for ( i = 0
 636             ; (string[ base + i ] != NUL) && (string[ base + i ] != ' ')
 637             ; i++ ) {
 638          /* empty */ ;
 639       }
 640
 641       if ( i > 0 ) {
 642          /* If the string was non-zero length, add it to the table.  We
 643           * can get zero length strings if there is a space at the end of
 644           * the string or if there are two (or more) spaces next to each
 645           * other in the string.
 646           */
 647
 648          string_tab[ idx ] = malloc( sizeof( char ) * (i + 1) );
 649          if ( string_tab[ idx ] == NULL ) {
 650             return;
 651          }
 652
 653          (void) memcpy( string_tab[ idx ], & string[ base ], i );
 654          string_tab[ idx ][i] = NUL;
 655          idx++;
 656       }
 657
 658
 659       /* Skip to the start of the next extension string.
 660        */
 661
 662       for ( base += i
 663             ; (string[ base ] == ' ') && (string[ base ] != NUL)
 664             ; base++ ) {
 665          /* empty */ ;
 666       }
 667    }
 668
 669    extension_table = string_tab;
 670    num_extensions = idx;
 671 }
 672
 673
 674 /**
 675  * Determine of an extension is supported.  The extension string table
 676  * must have already be initialized by calling \c make_extension_table.
 677  *
 678  * \praram ext  Extension to be tested.
 679  * \return GL_TRUE of the extension is supported, GL_FALSE otherwise.
 680  * \sa make_extension_table
 681  */
 682
 683 static GLboolean
 684 is_extension_supported( const char * ext )
 685 {
 686    unsigned   i;
 687
 688    for ( i = 0 ; i < num_extensions ; i++ ) {
 689       if ( strcmp( ext, extension_table[i] ) == 0 ) {
 690          return GL_TRUE;
 691       }
 692    }
 693
 694    return GL_FALSE;
 695 }
 696
 697
 698 int
 699 main(int argc, char *argv[])
 700 {
 701    Display *dpy;
 702    Window win;
 703    GLXContext ctx;
 704    char *dpyName = ":0";
 705    int swap_interval = 1;
 706    GLboolean do_swap_interval = GL_FALSE;
 707    GLboolean force_get_rate = GL_FALSE;
 708    GLboolean printInfo = GL_FALSE;
 709    int i;
 710    PFNGLXSWAPINTERVALMESAPROC set_swap_interval = NULL;
 711    PFNGLXGETSWAPINTERVALMESAPROC get_swap_interval = NULL;
 712
 713
 714    for (i = 1; i < argc; i++) {
 715       if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) {
 716          dpyName = argv[i+1];
 717          i++;
 718       }
 719       else if (strcmp(argv[i], "-info") == 0) {
 720          printInfo = GL_TRUE;
 721       }
 722       else if (strcmp(argv[i], "-swap") == 0 && i + 1 < argc) {
 723          swap_interval = atoi( argv[i+1] );
 724          do_swap_interval = GL_TRUE;
 725          i++;
 726       }
 727       else if (strcmp(argv[i], "-forcegetrate") == 0) {
 728          /* This option was put in because some DRI drivers don't support the
 729           * full GLX_OML_sync_control extension, but they do support
 730           * glXGetMscRateOML.
 731           */
 732          force_get_rate = GL_TRUE;
 733       }
 734       else if (strcmp(argv[i], "-ztrick") == 0) {
 735          use_ztrick = GL_TRUE;
 736       }
 737       else if (strcmp(argv[i], "-help") == 0) {
 738          printf("Usage:\n");
 739          printf("  gears [options]\n");
 740          printf("Options:\n");
 741          printf("  -help                   Print this information\n");
 742          printf("  -display displayName    Specify X display\n");
 743          printf("  -info                   Display GL information\n");
 744          printf("  -swap N                 Swap no more than once per N vertical refreshes\n");
 745          printf("  -forcegetrate           Try to use glXGetMscRateOML function\n");
 746          return 0;
 747       }
 748    }
 749
 750    dpy = XOpenDisplay(dpyName);
 751    if (!dpy) {
 752       printf("Error: couldn't open display %s\n", XDisplayName(dpyName));
 753       return -1;
 754    }
 755
 756    make_window(dpy, "glxgears", 0, 0, 300, 300, &win, &ctx);
 757    XMapWindow(dpy, win);
 758    glXMakeCurrent(dpy, win, ctx);
 759
 760    make_extension_table( (char *) glXQueryExtensionsString(dpy,DefaultScreen(dpy)) );
 761    has_OML_sync_control = is_extension_supported( "GLX_OML_sync_control" );
 762    has_SGI_swap_control = is_extension_supported( "GLX_SGI_swap_control" );
 763    has_MESA_swap_control = is_extension_supported( "GLX_MESA_swap_control" );
 764    has_MESA_swap_frame_usage = is_extension_supported( "GLX_MESA_swap_frame_usage" );
 765
 766    if ( has_MESA_swap_control ) {
 767       set_swap_interval = (PFNGLXSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXSwapIntervalMESA" );
 768       get_swap_interval = (PFNGLXGETSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetSwapIntervalMESA" );
 769    }
 770    else if ( has_SGI_swap_control ) {
 771       set_swap_interval = (PFNGLXSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXSwapIntervalSGI" );
 772    }
 773
 774
 775    if ( has_MESA_swap_frame_usage ) {
 776       get_frame_usage = (PFNGLXGETFRAMEUSAGEMESAPROC)  glXGetProcAddressARB( (const GLubyte *) "glXGetFrameUsageMESA" );
 777    }
 778
 779
 780    if (printInfo) {
 781       printf("GL_RENDERER   = %s\n", (char *) glGetString(GL_RENDERER));
 782       printf("GL_VERSION    = %s\n", (char *) glGetString(GL_VERSION));
 783       printf("GL_VENDOR     = %s\n", (char *) glGetString(GL_VENDOR));
 784       printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS));
 785       if ( has_OML_sync_control || force_get_rate ) {
 786          show_refresh_rate( dpy );
 787       }
 788
 789       if ( get_swap_interval != NULL ) {
 790          printf("Default swap interval = %d\n", (*get_swap_interval)() );
 791       }
 792    }
 793
 794    if ( do_swap_interval ) {
 795       if ( set_swap_interval != NULL ) {
 796          if ( ((swap_interval == 0) && !has_MESA_swap_control)
 797               || (swap_interval < 0) ) {
 798             printf( "Swap interval must be non-negative or greater than zero "
 799                     "if GLX_MESA_swap_control is not supported.\n" );
 800          }
 801          else {
 802             (*set_swap_interval)( swap_interval );
 803          }
 804
 805          if ( printInfo && (get_swap_interval != NULL) ) {
 806             printf("Current swap interval = %d\n", (*get_swap_interval)() );
 807          }
 808       }
 809       else {
 810          printf("Unable to set swap-interval.  Neither GLX_SGI_swap_control "
 811                 "nor GLX_MESA_swap_control are supported.\n" );
 812       }
 813    }
 814
 815    init();
 816
 817    event_loop(dpy, win);
 818
 819    glXDestroyContext(dpy, ctx);
 820    XDestroyWindow(dpy, win);
 821    XCloseDisplay(dpy);
 822
 823    return 0;
 824 }