/* * Copyright (C) 1999-2001 Brian Paul All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included * in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* * This is a port of the infamous "gears" demo to straight GLX (i.e. no GLUT) * Port by Brian Paul 23 March 2001 * * Modified by Ian Romanick 09 April 2003 to support * GLX_{MESA,SGI}_swap_control and GLX_OML_sync_control. * *Modified to make a simple full-framebuffer-fullscreen page-flip stress test... * * Command line options: * -display Name of the display to use. * -info print GL implementation information * -swap N Attempt to set the swap interval to 1/N second * -forcegetrate Get the display refresh rate even if the required GLX * extension is not supported. */ #include #include #include #include #include #include #ifndef __VMS /*# include */ #endif # define GLX_GLXEXT_PROTOTYPES #include #include #include //gluErrorString #define TEXTURE_SIZE_X 2048 #define TEXTURE_SIZE_Y 2048 #define OTHER_GEARS_COUNT 4 #define ATLAS_COUNT (4 + OTHER_GEARS_COUNT) GLuint TextureIds[ATLAS_COUNT]; #ifndef GLX_MESA_swap_control typedef GLint ( * PFNGLXSWAPINTERVALMESAPROC) (unsigned interval); typedef GLint ( * PFNGLXGETSWAPINTERVALMESAPROC) ( void ); #endif #if !defined( GLX_OML_sync_control ) && defined( _STDINT_H ) #define GLX_OML_sync_control 1 typedef Bool ( * PFNGLXGETMSCRATEOMLPROC) (Display *dpy, GLXDrawable drawable, int32_t *numerator, int32_t *denominator); #endif #ifndef GLX_MESA_swap_frame_usage #define GLX_MESA_swap_frame_usage 1 typedef int ( * PFNGLXGETFRAMEUSAGEMESAPROC) (Display *dpy, GLXDrawable drawable, float * usage ); #endif #define BENCHMARK PFNGLXGETFRAMEUSAGEMESAPROC get_frame_usage = NULL; #ifdef BENCHMARK /* XXX this probably isn't very portable */ #include #include #define NUL '\0' /* return current time (in seconds) */ static int current_time(void) { struct timeval tv; #ifdef __VMS (void) gettimeofday(&tv, NULL ); #else struct timezone tz; (void) gettimeofday(&tv, &tz); #endif return (int) tv.tv_sec; } #else /*BENCHMARK*/ /* dummy */ static int current_time(void) { return 0; } #endif /*BENCHMARK*/ #ifndef M_PI #define M_PI 3.14159265 #endif static GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0; static GLint gear1, gear2, gear3, gear4; static GLfloat angle = 0.0; static GLboolean has_OML_sync_control = GL_FALSE; static GLboolean has_SGI_swap_control = GL_FALSE; static GLboolean has_MESA_swap_control = GL_FALSE; static GLboolean has_MESA_swap_frame_usage = GL_FALSE; static char ** extension_table = NULL; static unsigned num_extensions; static GLboolean use_ztrick = GL_FALSE; static GLfloat aspectX = 1.0f, aspectY = 1.0f; /* * * Draw a gear wheel. You'll probably want to call this function when * building a display list since we do a lot of trig here. * * Input: inner_radius - radius of hole at center * outer_radius - radius at center of teeth * width - width of gear * teeth - number of teeth * tooth_depth - depth of tooth */ static void gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width, GLint teeth, GLfloat tooth_depth) { GLint i; GLfloat r0, r1, r2; GLfloat angle, da; GLfloat u, v, len; r0 = inner_radius; r1 = outer_radius - tooth_depth / 2.0; r2 = outer_radius + tooth_depth / 2.0; da = 2.0 * M_PI / teeth / 4.0; glShadeModel(GL_FLAT); glNormal3f(0.0, 0.0, 1.0); //glBindTexture(GL_TEXTURE_2D, TextureIds[ TextureNum ]); glEnable(GL_TEXTURE_2D); //probably wrong, but just use texture to load gpu /* draw front face */ glBegin(GL_QUAD_STRIP); for (i = 0; i <= teeth; i++) { angle = i * 2.0 * M_PI / teeth; glTexCoord2f(r0 * cos(angle), r0 * sin(angle)); glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); glTexCoord2f(r1 * cos(angle), r1 * sin(angle)); glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); if (i < teeth) { glTexCoord2f(r0 * cos(angle), r0 * sin(angle)); glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); glTexCoord2f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da)); glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da),width * 0.5); } } glEnd(); /* draw front sides of teeth */ glBegin(GL_QUADS); da = 2.0 * M_PI / teeth / 4.0; for (i = 0; i < teeth; i++) { angle = i * 2.0 * M_PI / teeth; glTexCoord2f(r1 * cos(angle), r1 * sin(angle)); glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); glTexCoord2f(r2 * cos(angle + da), r2 * sin(angle + da)); glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5); glTexCoord2f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da) ); glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5); glTexCoord2f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da) ); glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5); } glEnd(); glDisable(GL_TEXTURE_2D); glNormal3f(0.0, 0.0, -1.0); /* draw back face */ glBegin(GL_QUAD_STRIP); for (i = 0; i <= teeth; i++) { angle = i * 2.0 * M_PI / teeth; glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); if (i < teeth) { glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5); glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); } } glEnd(); /* draw back sides of teeth */ glBegin(GL_QUADS); da = 2.0 * M_PI / teeth / 4.0; for (i = 0; i < teeth; i++) { angle = i * 2.0 * M_PI / teeth; glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5); glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5); glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5); glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); } glEnd(); /* draw outward faces of teeth */ glBegin(GL_QUAD_STRIP); for (i = 0; i < teeth; i++) { angle = i * 2.0 * M_PI / teeth; glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5); glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5); u = r2 * cos(angle + da) - r1 * cos(angle); v = r2 * sin(angle + da) - r1 * sin(angle); len = sqrt(u * u + v * v); u /= len; v /= len; glNormal3f(v, -u, 0.0); glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5); glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5); glNormal3f(cos(angle), sin(angle), 0.0); glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5); glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5); u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da); v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da); glNormal3f(v, -u, 0.0); glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5); glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5); glNormal3f(cos(angle), sin(angle), 0.0); } glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5); glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5); glEnd(); glShadeModel(GL_SMOOTH); /* draw inside radius cylinder */ glBegin(GL_QUAD_STRIP); for (i = 0; i <= teeth; i++) { angle = i * 2.0 * M_PI / teeth; glNormal3f(-cos(angle), -sin(angle), 0.0); glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5); glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5); } glEnd(); } static void draw(void) { if ( use_ztrick ) { static GLboolean flip = GL_FALSE; static const GLfloat vert[4][3] = { { -1, -1, -0.999 }, { 1, -1, -0.999 }, { 1, 1, -0.999 }, { -1, 1, -0.999 } }; static const GLfloat col[4][3] = { { 1.0, 0.6, 0.0 }, { 1.0, 0.6, 0.0 }, { 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 }, }; if ( flip ) { glDepthRange(0, 0.5); glDepthFunc(GL_LEQUAL); } else { glDepthRange(1.0, 0.4999); glDepthFunc(GL_GEQUAL); } flip = !flip; /* The famous Quake "Z trick" only works when the whole screen is * re-drawn each frame. */ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1, 1, -1, 1, -1, 1); glDisable(GL_LIGHTING); glShadeModel(GL_SMOOTH); glEnable( GL_VERTEX_ARRAY ); glEnable( GL_COLOR_ARRAY ); glVertexPointer( 3, GL_FLOAT, 0, vert ); glColorPointer( 3, GL_FLOAT, 0, col ); glDrawArrays( GL_POLYGON, 0, 4 ); glDisable( GL_COLOR_ARRAY ); glDisable( GL_VERTEX_ARRAY ); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(-aspectX, aspectX, -aspectY, aspectY, 5.0, 60.0); glEnable(GL_LIGHTING); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0, 0.0, -45.0); } else { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); } glPushMatrix(); glRotatef(view_rotx, 1.0, 0.0, 0.0); glRotatef(view_roty, 0.0, 1.0, 0.0); glRotatef(view_rotz, 0.0, 0.0, 1.0); glPushMatrix(); glTranslatef(-3.0, -2.0, 0.0); glRotatef(angle, 0.0, 0.0, 1.0); glBindTexture(GL_TEXTURE_2D, TextureIds[0]); glCallList(gear1); glPopMatrix(); glPushMatrix(); glTranslatef(3.1, -2.0, 0.0); glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0); glBindTexture(GL_TEXTURE_2D, TextureIds[1]); glCallList(gear2); glPopMatrix(); glPushMatrix(); glTranslatef(-3.1, 4.2, 0.0); glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0); glBindTexture(GL_TEXTURE_2D, TextureIds[2]); glCallList(gear3); glPopMatrix(); glPushMatrix(); glTranslatef(-10.1, 0.2, 0.0); glRotatef(-0.2 * angle - 25.0, 0.0, 0.0, 1.0); glBindTexture(GL_TEXTURE_2D, TextureIds[3]); glCallList(gear4); glPopMatrix(); int Counter; for (Counter = 0; Counter < OTHER_GEARS_COUNT; Counter++) { float CoordModifier = 3.0 * Counter; uint8_t Sense = Counter &1; glPushMatrix(); glTranslatef(3.1 + 2.4*CoordModifier, 4.2 + CoordModifier / 4, 0.0); glRotatef( (Sense ? -2.0 : 2.0) * angle - 25.0, 0.0, 0.0, 1.0); glBindTexture(GL_TEXTURE_2D, TextureIds[4 + Counter]); glCallList(gear3); glPopMatrix(); glPushMatrix(); glTranslatef(8.0 + 3.3* CoordModifier, -7.0 + CoordModifier / 2, 0.0); glRotatef( (Sense ? -1.0 : 1.0) * angle, 0.0, 0.0, 1.0); glCallList(gear1); glPopMatrix(); } glPopMatrix(); } /* new window size or exposure */ static void reshape(int width, int height) { if (width > height) { aspectX = (GLfloat) width / (GLfloat) height; aspectY = 1.0; } else { aspectX = 1.0; aspectY = (GLfloat) height / (GLfloat) width; } glViewport(0, 0, (GLint) width, (GLint) height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(-aspectX, aspectX, -aspectY, aspectY, 5.0, 60.0); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0.0, 0.0, -45.0); } static void init(void) { static GLfloat pos[4] = { 5.0, 5.0, 10.0, 0.0 }; /* static GLfloat red[4] = { 0.8, 0.1, 0.0, 1.0 }; static GLfloat green[4] = { 0.0, 0.8, 0.2, 1.0 }; static GLfloat blue[4] = { 0.2, 0.2, 1.0, 1.0 }; static GLfloat acolor[4] = { 0.2, 0.3, 0.4, 0.6 }; */ glLightfv(GL_LIGHT0, GL_POSITION, pos); glEnable(GL_CULL_FACE); glEnable(GL_LIGHTING); glEnable(GL_LIGHT0); glEnable(GL_DEPTH_TEST); /* make the gears */ gear1 = glGenLists(1); glNewList(gear1, GL_COMPILE); //glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, red); gear(1.0, 4.0, 1.0, 20, 0.7); glEndList(); gear2 = glGenLists(1); glNewList(gear2, GL_COMPILE); //glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, green); gear(0.5, 2.0, 2.0, 10, 0.7); glEndList(); gear3 = glGenLists(1); glNewList(gear3, GL_COMPILE); //glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue); gear(1.3, 2.0, 0.5, 10, 0.7); glEndList(); gear4 = glGenLists(1); glNewList(gear4, GL_COMPILE); //glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, acolor); gear(4.5, 9.0, 3.0, 40, 0.7); glEndList(); glEnable(GL_NORMALIZE); } /** * Remove window border/decorations. */ static void no_border( Display *dpy, Window w) { static const unsigned MWM_HINTS_DECORATIONS = (1 << 1); static const int PROP_MOTIF_WM_HINTS_ELEMENTS = 5; typedef struct { unsigned long flags; unsigned long functions; unsigned long decorations; long inputMode; unsigned long status; } PropMotifWmHints; PropMotifWmHints motif_hints; Atom prop, proptype; unsigned long flags = 0; /* setup the property */ motif_hints.flags = MWM_HINTS_DECORATIONS; motif_hints.decorations = flags; /* get the atom for the property */ prop = XInternAtom( dpy, "_MOTIF_WM_HINTS", True ); if (!prop) { /* something went wrong! */ return; } /* not sure this is correct, seems to work, XA_WM_HINTS didn't work */ proptype = prop; XChangeProperty( dpy, w, /* display, window */ prop, proptype, /* property, type */ 32, /* format: 32-bit datums */ PropModeReplace, /* mode */ (unsigned char *) &motif_hints, /* data */ PROP_MOTIF_WM_HINTS_ELEMENTS /* nelements */ ); } //----------------------------------------------------------------------------- void modify_window(Display *X11Dpy, Window WinId) { Atom prop; // get the atom for the property prop = XInternAtom( X11Dpy, "_MOTIF_WM_HINTS", True ); if (prop != None) { #define MWM_HINTS_FUNCTIONS (1 << 0) #define MWM_HINTS_DECORATIONS (1 << 1) #define MWM_HINTS_INPUT_MODE (1 << 2) #define MWM_HINTS_STATUS (1 << 3) #define PROP_MOTIF_WM_HINTS_ELEMENTS 5 typedef struct { unsigned long flags; unsigned long functions; unsigned long decorations; long inputMode; unsigned long status; } PropMotifWmHints; PropMotifWmHints motif_hints; // setup the property motif_hints.flags = MWM_HINTS_DECORATIONS | MWM_HINTS_INPUT_MODE; // | MWM_HINTS_STATUS; motif_hints.decorations = 0; //motif_hints.status = 0; motif_hints.inputMode = 0; int TmpRes = XChangeProperty(X11Dpy, WinId, // display, window prop, prop, // property, type 32, // format: 32-bit datums PropModeReplace, // mode (unsigned char *) &motif_hints, // data PROP_MOTIF_WM_HINTS_ELEMENTS // num elements in data ); printf("_MOTIF_WM_HINTS result: %d\n", TmpRes); } // try KDE hints prop = XInternAtom(X11Dpy, "KWM_WIN_DECORATION", True); if (prop != None) { unsigned Hints = 0; int TmpRes = XChangeProperty(X11Dpy, WinId, prop, prop, 32, PropModeReplace, (unsigned char *) &Hints, 1); printf("KWM_WIN_DECORATION result: %d\n", TmpRes); } // try GNOME hints prop = XInternAtom(X11Dpy, "_WIN_HINTS", True); if (prop != None) { unsigned Hints = 0; int TmpRes = XChangeProperty(X11Dpy, WinId, prop, prop, 32, PropModeReplace, (unsigned char *) &Hints, 1); printf("_WIN_HINTS result: %d\n", TmpRes); } prop = XInternAtom(X11Dpy, "_NET_WM_BYPASS_COMPOSITOR", False); if (prop != None) { unsigned Hints = 1; int TmpRes = XChangeProperty(X11Dpy, WinId, prop, prop, 32, PropModeReplace, (unsigned char *) &Hints, 1); printf("_NET_WM_BYPASS_COMPOSITOR result: %d\n", TmpRes); } // Configure window XWindowChanges WindowConfig; WindowConfig.stack_mode = Above; //TopIf; //Above; WindowConfig.sibling = DefaultRootWindow(X11Dpy); WindowConfig.border_width = 0; XConfigureWindow(X11Dpy, WinId, CWStackMode, &WindowConfig); } void SetStayOnTop(Display *X11Dpy, Window WinId) { //_NET_WM_STATE _NET_WM_FULLSCREEN_MONITORS #define _NET_WM_STATE_REMOVE 0 // remove/unset property #define _NET_WM_STATE_ADD 1 // add/set property #define _NET_WM_STATE_TOGGLE 2 // toggle property // change a window's _NET_WM_STATE property so that it can be kept on top. // @display: x11 display singleton. // @xid : the window to set on top. XEvent event; event.xclient.type = ClientMessage; event.xclient.serial = 0; event.xclient.send_event = True; event.xclient.display = X11Dpy; event.xclient.window = WinId; event.xclient.message_type = XInternAtom (X11Dpy, "_NET_WM_STATE", True); event.xclient.format = 32; event.xclient.data.l[0] = _NET_WM_STATE_ADD; event.xclient.data.l[1] = XInternAtom (X11Dpy, "_NET_WM_STATE_ABOVE", True); event.xclient.data.l[2] = 0; //unused. event.xclient.data.l[3] = 0; event.xclient.data.l[4] = 0; XSendEvent (X11Dpy, DefaultRootWindow(X11Dpy), False, SubstructureRedirectMask|SubstructureNotifyMask, &event); XFlush (X11Dpy); #if 0 event.xclient.type = ClientMessage; event.xclient.serial = 0; event.xclient.send_event = True; event.xclient.display = X11Dpy; event.xclient.window = WinId; event.xclient.message_type = XInternAtom (X11Dpy, "_NET_WM_STATE", True); event.xclient.format = 32; event.xclient.data.l[0] = _NET_WM_STATE_ADD; event.xclient.data.l[1] = XInternAtom (X11Dpy, "_NET_WM_STATE_FULLSCREEN", True); event.xclient.data.l[2] = 0; //unused. event.xclient.data.l[3] = 1; event.xclient.data.l[4] = 0; XSendEvent (X11Dpy, DefaultRootWindow(X11Dpy), False, SubstructureRedirectMask|SubstructureNotifyMask, &event); XFlush (X11Dpy); #endif } /* * Create an RGB, double-buffered window. * Return the window and context handles. */ static void make_window( Display *dpy, const char *name, int x, int y, int width, int height, GLboolean fullscreen, Window *winRet, GLXContext *ctxRet) { int attrib[] = { GLX_RGBA, GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, GLX_ALPHA_SIZE, 8, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 1, None }; int scrnum; XSetWindowAttributes attr; unsigned long mask; Window root; Window win; GLXContext ctx; XVisualInfo *visinfo; scrnum = DefaultScreen( dpy ); root = RootWindow( dpy, scrnum ); if (fullscreen) { x = y = 0; width = DisplayWidth( dpy, scrnum ); height = DisplayHeight( dpy, scrnum ); } visinfo = glXChooseVisual( dpy, scrnum, attrib ); if (!visinfo) { printf("Error: couldn't get an RGB, Double-buffered visual\n"); exit(1); } /* window attributes */ attr.background_pixel = 0; attr.border_pixel = 0; attr.colormap = XCreateColormap( dpy, root, visinfo->visual, AllocNone); attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask; mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask; win = XCreateWindow( dpy, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr ); /* set hints and properties */ { XSizeHints sizehints; if (fullscreen) { sizehints.x = 0; sizehints.y = 0; sizehints.width = width; sizehints.height = height; sizehints.max_width = width; sizehints.max_height = height; sizehints.min_width = width; sizehints.min_height = height; sizehints.flags = PPosition | PSize | PMinSize | PMaxSize; } else { sizehints.x = x; sizehints.y = y; sizehints.width = width; sizehints.height = height; sizehints.flags = USSize | USPosition; } XSetNormalHints(dpy, win, &sizehints); XSetStandardProperties(dpy, win, name, name, None, (char **)NULL, 0, &sizehints); } if (fullscreen) modify_window(dpy, win); //no_border(dpy, win); ctx = glXCreateContext( dpy, visinfo, NULL, True ); if (!ctx) { printf("Error: glXCreateContext failed\n"); exit(1); } XFree(visinfo); *winRet = win; *ctxRet = ctx; } static void event_loop(Display *dpy, Window win) { float frame_usage = 0.0; while (1) { while (XPending(dpy) > 0) { XEvent event; XNextEvent(dpy, &event); switch (event.type) { case Expose: /* we'll redraw below */ break; case ConfigureNotify: reshape(event.xconfigure.width, event.xconfigure.height); break; case KeyPress: { char buffer[10]; int r, code; code = XLookupKeysym(&event.xkey, 0); if (code == XK_Left) { view_roty += 5.0; } else if (code == XK_Right) { view_roty -= 5.0; } else if (code == XK_Up) { view_rotx += 5.0; } else if (code == XK_Down) { view_rotx -= 5.0; } else { r = XLookupString(&event.xkey, buffer, sizeof(buffer), NULL, NULL); if (buffer[0] == 27) { /* escape */ return; } } } } } /* next frame */ angle += 2.0; draw(); if ( get_frame_usage != NULL ) { GLfloat temp; (*get_frame_usage)( dpy, win, & temp ); frame_usage += temp; } glXSwapBuffers(dpy, win); /* calc framerate */ { static int t0 = -1; static int frames = 0; int t = current_time(); if (t0 < 0) t0 = t; frames++; if (t - t0 >= 5.0) { GLfloat seconds = t - t0; GLfloat fps = frames / seconds; if ( get_frame_usage != NULL ) { printf("%d frames in %3.1f seconds = %6.3f FPS (%3.1f%% usage)\n", frames, seconds, fps, (frame_usage * 100.0) / (float) frames ); } else { printf("%d frames in %3.1f seconds = %6.3f FPS\n", frames, seconds, fps); } t0 = t; frames = 0; frame_usage = 0.0; } } } } /** * Display the refresh rate of the display using the GLX_OML_sync_control * extension. */ static void show_refresh_rate( Display * dpy ) { #if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) PFNGLXGETMSCRATEOMLPROC get_msc_rate; int32_t n; int32_t d; get_msc_rate = (PFNGLXGETMSCRATEOMLPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetMscRateOML" ); if ( get_msc_rate != NULL ) { (*get_msc_rate)( dpy, glXGetCurrentDrawable(), &n, &d ); printf( "refresh rate: %.1fHz\n", (float) n / d ); return; } #endif printf( "glXGetMscRateOML not supported.\n" ); } /** * Fill in the table of extension strings from a supplied extensions string * (as returned by glXQueryExtensionsString). * * \param string String of GLX extensions. * \sa is_extension_supported */ static void make_extension_table( const char * string ) { char ** string_tab; unsigned num_strings; unsigned base; unsigned idx; unsigned i; /* Count the number of spaces in the string. That gives a base-line * figure for the number of extension in the string. */ num_strings = 1; for ( i = 0 ; string[i] != NUL ; i++ ) { if ( string[i] == ' ' ) { num_strings++; } } string_tab = (char **) malloc( sizeof( char * ) * num_strings ); if ( string_tab == NULL ) { return; } base = 0; idx = 0; while ( string[ base ] != NUL ) { /* Determine the length of the next extension string. */ for ( i = 0 ; (string[ base + i ] != NUL) && (string[ base + i ] != ' ') ; i++ ) { /* empty */ ; } if ( i > 0 ) { /* If the string was non-zero length, add it to the table. We * can get zero length strings if there is a space at the end of * the string or if there are two (or more) spaces next to each * other in the string. */ string_tab[ idx ] = (char *)malloc( sizeof( char ) * (i + 1) ); if ( string_tab[ idx ] == NULL ) { return; } (void) memcpy( string_tab[ idx ], & string[ base ], i ); string_tab[ idx ][i] = NUL; idx++; } /* Skip to the start of the next extension string. */ for ( base += i ; (string[ base ] == ' ') && (string[ base ] != NUL) ; base++ ) { /* empty */ ; } } extension_table = string_tab; num_extensions = idx; } /** * Determine of an extension is supported. The extension string table * must have already be initialized by calling \c make_extension_table. * * \praram ext Extension to be tested. * \return GL_TRUE of the extension is supported, GL_FALSE otherwise. * \sa make_extension_table */ static GLboolean is_extension_supported( const char * ext ) { unsigned i; for ( i = 0 ; i < num_extensions ; i++ ) { if ( strcmp( ext, extension_table[i] ) == 0 ) { return GL_TRUE; } } return GL_FALSE; } int (*PrevX11ErrHandler)(Display *, XErrorEvent *) = NULL; int X11ErrorHandler(Display *X11Dpy, XErrorEvent *ErrorEvent) { char Buffer[128]; XGetErrorText(X11Dpy, ErrorEvent->error_code, Buffer, sizeof(Buffer)); printf("X11 Error: %d(%d,%d),%s\n", ErrorEvent->error_code, ErrorEvent->request_code, ErrorEvent->minor_code, Buffer); if (PrevX11ErrHandler) return PrevX11ErrHandler(X11Dpy, ErrorEvent); else return 0; } void MakeTextures() { GLenum ErrorCod; GLuint* ioMem = malloc(sizeof(GLuint) * TEXTURE_SIZE_X * TEXTURE_SIZE_Y); glGenTextures(ATLAS_COUNT, TextureIds); int TextureIndex = 0; for (TextureIndex = 0; TextureIndex < ATLAS_COUNT; TextureIndex++) { int x,y; for (x = 0; x < TEXTURE_SIZE_X; x++) { for (y = 0; y < TEXTURE_SIZE_Y; y++) { //coord could be wrong, just fill with some color ioMem[x * TEXTURE_SIZE_X + y] = (((x/40 + TextureIndex *50) &0xFF) << 24) | //R (( (192 - TextureIndex *20) << 16) && 0xFF0000) | //((y&0xFF) << 16) | //G ((((x+y + 500)/(5* (TextureIndex+1) )) & 0xFF) << 8) | //B 200; //((x*y) & 0xFF); //A } } glBindTexture(GL_TEXTURE_2D, TextureIds[TextureIndex]); if ( (ErrorCod = glGetError()) != 0) { printf("glBindTexture(%d) %d, %s\n", TextureIndex, ErrorCod, gluErrorString(ErrorCod) ); exit(1); } glPixelStorei(GL_UNPACK_ALIGNMENT, 8); glPixelStorei(GL_UNPACK_ROW_LENGTH, TEXTURE_SIZE_X); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // Use nice (linear) scaling glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); // Use nice (linear) scaling glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEXTURE_SIZE_X, TEXTURE_SIZE_Y, 0, GL_RGBA, GL_UNSIGNED_BYTE, ioMem); if ( (ErrorCod = glGetError()) != 0) { printf("glTexImage2D %d, %s\n", ErrorCod, gluErrorString(ErrorCod) ); exit(1); } glBindTexture(GL_TEXTURE_2D, 0); glFlush(); } free(ioMem); glBindTexture(GL_TEXTURE_2D, TextureIds[0]); glEnable(GL_TEXTURE_2D); } #define __GLU_CHECK_GLERROR(TEXT) do { GLint ErrorCod; \ if ( (ErrorCod = glGetError()) != 0) \ printf("%s %d, %s\n", TEXT, ErrorCod, gluErrorString(ErrorCod) ); } while (0) int main(int argc, char *argv[]) { Display *dpy; Window win; GLXContext ctx; const char *dpyName = ":0"; int swap_interval = 2; //30 fps on a 60 HZ monitor. // 1; GLboolean do_swap_interval = GL_TRUE; //GL_FALSE; GLboolean force_get_rate = GL_FALSE; GLboolean fullscreen = GL_TRUE; //GL_FALSE; GLboolean printInfo = GL_FALSE; int i; PFNGLXSWAPINTERVALMESAPROC set_swap_interval = NULL; PFNGLXGETSWAPINTERVALMESAPROC get_swap_interval = NULL; int width = 300, height = 300; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-display") == 0 && i + 1 < argc) { dpyName = argv[i+1]; i++; } else if (strcmp(argv[i], "-info") == 0) { printInfo = GL_TRUE; } else if (strcmp(argv[i], "-swap") == 0 && i + 1 < argc) { swap_interval = atoi( argv[i+1] ); do_swap_interval = GL_TRUE; i++; } else if (strcmp(argv[i], "-forcegetrate") == 0) { /* This option was put in because some DRI drivers don't support the * full GLX_OML_sync_control extension, but they do support * glXGetMscRateOML. */ force_get_rate = GL_TRUE; } else if (strcmp(argv[i], "-fullscreen") == 0) { fullscreen = GL_TRUE; } else if (strcmp(argv[i], "-ztrick") == 0) { use_ztrick = GL_TRUE; } else if (strcmp(argv[i], "-help") == 0) { printf("Usage:\n"); printf(" gears [options]\n"); printf("Options:\n"); printf(" -help Print this information\n"); printf(" -display displayName Specify X display\n"); printf(" -info Display GL information\n"); printf(" -swap N Swap no more than once per N vertical refreshes\n"); printf(" -forcegetrate Try to use glXGetMscRateOML function\n"); printf(" -fullscreen Full-screen window\n"); return 0; } } dpy = XOpenDisplay(dpyName); if (!dpy) { printf("Error: couldn't open display %s\n", XDisplayName(dpyName)); return -1; } PrevX11ErrHandler = XSetErrorHandler(X11ErrorHandler); if (fullscreen) { width = DisplayWidth(dpy, DefaultScreen(dpy)); height = DisplayHeight(dpy, DefaultScreen(dpy)); printf("Detected display of width: %d, height: %d\n", width, height); if ( (width != 1366*2) && (width != 1368*2) && (width != 1920*2) && (width != 1600*2) && (width != 1680*2) ) { printf("For this test must be 2 monitors, one next the other, same resolution\n"); exit(1); } } else { printf("Must be fullscreen\n"); exit(1); } make_window(dpy, "glx_swapbuf_test", 0, 0, width, height, fullscreen, &win, &ctx); XMapWindow(dpy, win); SetStayOnTop(dpy, win); glXMakeCurrent(dpy, win, ctx); glEnable(GL_BLEND); __GLU_CHECK_GLERROR("GL_BLEND"); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); __GLU_CHECK_GLERROR("glBlendFunc"); glActiveTexture(GL_TEXTURE0); glEnable(GL_TEXTURE_2D); MakeTextures(); make_extension_table( (char *) glXQueryExtensionsString(dpy,DefaultScreen(dpy)) ); has_OML_sync_control = is_extension_supported( "GLX_OML_sync_control" ); has_SGI_swap_control = is_extension_supported( "GLX_SGI_swap_control" ); has_MESA_swap_control = is_extension_supported( "GLX_MESA_swap_control" ); has_MESA_swap_frame_usage = is_extension_supported( "GLX_MESA_swap_frame_usage" ); if ( has_MESA_swap_control ) { set_swap_interval = (PFNGLXSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXSwapIntervalMESA" ); get_swap_interval = (PFNGLXGETSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetSwapIntervalMESA" ); } else if ( has_SGI_swap_control ) { set_swap_interval = (PFNGLXSWAPINTERVALMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXSwapIntervalSGI" ); } if ( has_MESA_swap_frame_usage ) { get_frame_usage = (PFNGLXGETFRAMEUSAGEMESAPROC) glXGetProcAddressARB( (const GLubyte *) "glXGetFrameUsageMESA" ); } if (printInfo) { printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER)); printf("GL_VERSION = %s\n", (char *) glGetString(GL_VERSION)); printf("GL_VENDOR = %s\n", (char *) glGetString(GL_VENDOR)); printf("GL_EXTENSIONS = %s\n", (char *) glGetString(GL_EXTENSIONS)); if ( has_OML_sync_control || force_get_rate ) { show_refresh_rate( dpy ); } if ( get_swap_interval != NULL ) { printf("Default swap interval = %d\n", (*get_swap_interval)() ); } } if ( do_swap_interval ) { if ( set_swap_interval != NULL ) { if ( ((swap_interval == 0) && !has_MESA_swap_control) || (swap_interval < 0) ) { printf( "Swap interval must be non-negative or greater than zero " "if GLX_MESA_swap_control is not supported.\n" ); } else { (*set_swap_interval)( swap_interval ); } if ( printInfo && (get_swap_interval != NULL) ) { printf("Current swap interval = %d\n", (*get_swap_interval)() ); } } else { printf("Unable to set swap-interval. Neither GLX_SGI_swap_control " "nor GLX_MESA_swap_control are supported.\n" ); } } init(); event_loop(dpy, win); glXDestroyContext(dpy, ctx); XDestroyWindow(dpy, win); XCloseDisplay(dpy); return 0; }