ruby-glfw 0.9

data/glfw-src/support/d/examples/listmodes.d

@@ -0,0 +1,48 @@
+//========================================================================
+// This is a small test application for GLFW.
+// The program lists all available fullscreen video modes.
+//========================================================================
+
+import glfw;
+
+// Maximum number of modes that we want to list
+const int MAX_NUM_MODES = 400;
+
+
+//========================================================================
+// main()
+//========================================================================
+
+int main()
+{
+    GLFWvidmode dtmode;
+    GLFWvidmode modes[ MAX_NUM_MODES ];
+    int     modecount, i;
+
+    // Initialize GLFW
+    if( !glfwInit() )
+    {
+        return 0;
+    }
+
+    // Show desktop video mode
+    glfwGetDesktopMode( &dtmode );
+    printf( "Desktop mode: %d x %d x %d\n\n",
+            dtmode.Width, dtmode.Height, dtmode.RedBits +
+            dtmode.GreenBits + dtmode.BlueBits );
+
+    // List available video modes
+    modecount = glfwGetVideoModes( modes, MAX_NUM_MODES );
+    printf( "Available modes:\n" );
+    for( i = 0; i < modecount; i ++ )
+    {
+        printf( "%3d: %d x %d x %d\n", i,
+                modes[i].Width, modes[i].Height, modes[i].RedBits +
+                modes[i].GreenBits + modes[i].BlueBits );
+    }
+
+    // Terminate GLFW
+    glfwTerminate();
+
+    return 0;
+}

data/glfw-src/support/d/examples/mipmaps.d

@@ -0,0 +1,126 @@
+//========================================================================
+// This is a small test application for GLFW.
+// The program shows texture loading with mipmap generation and trilienar
+// filtering.
+// Note: For OpenGL 1.0 compability, we do not use texture objects (this
+// is no issue, since we only have one texture).
+//========================================================================
+
+import glfw;
+import std.c.stdio;
+
+
+//========================================================================
+// main()
+//========================================================================
+
+int main( )
+{
+    int     width, height, running, frames, x, y;
+    double  t, t0, fps;
+    char    titlestr[ 200 ];
+
+    // Initialise GLFW
+    glfwInit();
+
+    // Open OpenGL window
+    if( !glfwOpenWindow( 640, 480, 0,0,0,0, 0,0, GLFW_WINDOW ) )
+    {
+        glfwTerminate();
+        return 0;
+    }
+
+    // Enable sticky keys
+    glfwEnable( GLFW_STICKY_KEYS );
+
+    // Disable vertical sync (on cards that support it)
+    glfwSwapInterval( 0 );
+
+    // Load texture from file, and build all mipmap levels. The
+    // texture is automatically uploaded to texture memory.
+    if( !glfwLoadTexture2D( "mipmaps.tga", GLFW_BUILD_MIPMAPS_BIT ) )
+    {
+        glfwTerminate();
+        return 0;
+    }
+
+    // Use trilinear interpolation (GL_LINEAR_MIPMAP_LINEAR)
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
+                     GL_LINEAR_MIPMAP_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
+                     GL_LINEAR );
+
+    // Enable texturing
+    glEnable( GL_TEXTURE_2D );
+
+    // Main loop
+    running = GL_TRUE;
+    frames = 0;
+    t0 = glfwGetTime();
+    while( running )
+    {
+        // Get time and mouse position
+        t = glfwGetTime();
+        glfwGetMousePos( &x, &y );
+
+        // Calculate and display FPS (frames per second)
+        if( (t-t0) > 1.0 || frames == 0 )
+        {
+            fps = cast(double)frames / (t-t0);
+            sprintf( titlestr, "Trilinear interpolation (%.1f FPS)", fps );
+            glfwSetWindowTitle( titlestr );
+            t0 = t;
+            frames = 0;
+        }
+        frames ++;
+
+        // Get window size (may be different than the requested size)
+        glfwGetWindowSize( &width, &height );
+        height = height > 0 ? height : 1;
+
+        // Set viewport
+        glViewport( 0, 0, width, height );
+
+        // Clear color buffer
+        glClearColor( 0.0f, 0.0f, 0.0f, 0.0f);
+        glClear( GL_COLOR_BUFFER_BIT );
+
+        // Select and setup the projection matrix
+        glMatrixMode( GL_PROJECTION );
+        glLoadIdentity();
+        gluPerspective( 65.0f, cast(GLfloat)width/cast(GLfloat)height, 1.0f,
+            50.0f );
+
+        // Select and setup the modelview matrix
+        glMatrixMode( GL_MODELVIEW );
+        glLoadIdentity();
+        gluLookAt( 0.0f,  3.0f, -20.0f,    // Eye-position
+                   0.0f, -4.0f, -11.0f,    // View-point
+                   0.0f,  1.0f,   0.0f );  // Up-vector
+
+        // Draw a textured quad
+        glRotatef( 0.05*cast(GLfloat)x + cast(GLfloat)t*5.0f, 0.0f, 1.0f, 0.0f );
+        glBegin( GL_QUADS );
+          glTexCoord2f( -20.0f,  20.0f );
+          glVertex3f( -50.0f, 0.0f, -50.0f );
+          glTexCoord2f(  20.0f,  20.0f );
+          glVertex3f(  50.0f, 0.0f, -50.0f );
+          glTexCoord2f(  20.0f, -20.0f );
+          glVertex3f(  50.0f, 0.0f,  50.0f );
+          glTexCoord2f( -20.0f, -20.0f );
+          glVertex3f( -50.0f, 0.0f,  50.0f );
+        glEnd();
+
+        // Swap buffers
+        glfwSwapBuffers();
+
+        // Check if the ESC key was pressed or the window was closed
+        running = !glfwGetKey( GLFW_KEY_ESC ) &&
+                  glfwGetWindowParam( GLFW_OPENED );
+    }
+
+    // Close OpenGL window and terminate GLFW
+    glfwTerminate();
+
+    return 0;
+}

data/glfw-src/support/d/examples/mtbench.d

@@ -0,0 +1,304 @@
+//========================================================================
+// Multithreading benchmark program, based on the GLFW multi threading
+// support.
+//
+// This program can be used to get an idea of what to expect in terms of
+// multithreading granularity performance.
+//
+// As a "bonus", this program demonstrates how to create a signal
+// primitive using the GLFW mutex and condition variable primitives.
+//
+// Here are some benchmark results:
+// (Note: these are not exact measurments, since they are subject to
+// varying CPU-loads etc. Some tested systems are multi-user systems
+// which were running under anything but optimal conditions)
+//
+// +------------+-------+-------------+-------------------+------------+
+// | Processor  |  CPUs |     OS      | Context switches  | Mean sleep |
+// |            |       |             |    per second     | time (ms)  |
+// +------------+-------+-------------+-------------------+------------+
+// |Athlon      |   1   | Linux       |       161942      |   20.000   |
+// |710 MHz     |       | 2.4.3       |                   |            |
+// +------------+-------+-------------+-------------------+------------+
+// |Athlon      |   1   | MS Win2k    |       525230      |   10.014   |
+// |710 MHz     |       |             |                   |            |
+// +------------+-------+-------------+-------------------+------------+
+// |Athlon      |   1   | MS Win 98   |        23564      |    4.947   |
+// |710 MHz     |       |             |                   |            |
+// +------------+-------+-------------+-------------------+------------+
+// |Pentium III |   1   | MS NT 4.0   |       304694      |   10.014   |
+// |500 MHz     |       |             |                   |            |
+// +------------+-------+-------------+-------------------+------------+
+// |UltraSPARC2 |   6   | SunOS 5.6   |       120867      |   19.355   |
+// |400 MHz     |       |             |                   |            |
+// +------------+-------+-------------+-------------------+------------+
+// |Alpha 21264 |   1   | OSF1        |       131993      |    3.097   |
+// |500 MHz     |       |             |                   |            |
+// +------------+-------+-------------+-------------------+------------+
+// |Alpha 21264 |   2   | OSF1        |        40836      |    1.397   |
+// |500 MHz     |       |             |                   |            |
+// +------------+-------+-------------+-------------------+------------+
+// |68020 (emu) |   1   | AmigaOS 3.1 |        50425      |   40.060   |
+// |~200 MHz    |       | (WinUAE)    |                   |            |
+// +------------+-------+-------------+-------------------+------------+
+//
+//========================================================================
+
+import glfw;
+import std.c.stdio;
+
+struct signal_t {
+    GLFWcond  cond;
+    GLFWmutex mutex;
+    int       flag;
+}
+
+signal_t gotoA, gotoB;
+
+GLFWcond threadDone;
+GLFWmutex doneMutex;
+int doneCount = 0;
+int gotoACount = 0;
+int gotoBCount = 0;
+
+const int MAX_COUNT = 10000;
+
+
+//------------------------------------------------------------------------
+// InitSignal()
+//------------------------------------------------------------------------
+
+void InitSignal( signal_t *s )
+{
+    s.cond  = glfwCreateCond();
+    s.mutex = glfwCreateMutex();
+    s.flag  = 0;
+}
+
+
+//------------------------------------------------------------------------
+// KillSignal()
+//------------------------------------------------------------------------
+
+void KillSignal( signal_t *s )
+{
+    glfwDestroyCond( s.cond );
+    glfwDestroyMutex( s.mutex );
+    s.flag  = 0;
+}
+
+
+//------------------------------------------------------------------------
+// WaitSignal()
+//------------------------------------------------------------------------
+
+void WaitSignal( signal_t *s )
+{
+    glfwLockMutex( s.mutex );
+    while( !s.flag )
+    {
+        glfwWaitCond( s.cond, s.mutex, GLFW_INFINITY );
+    }
+    s.flag = 0;
+    glfwUnlockMutex( s.mutex );
+}
+
+
+//------------------------------------------------------------------------
+// SetSignal()
+//------------------------------------------------------------------------
+
+void SetSignal( signal_t *s )
+{
+    glfwLockMutex( s.mutex );
+    s.flag = 1;
+    glfwUnlockMutex( s.mutex );
+    glfwSignalCond( s.cond );
+}
+
+
+//------------------------------------------------------------------------
+// main()
+//------------------------------------------------------------------------
+
+int main( )
+{
+    GLFWthread threadA, threadB;
+    double     t1, t2, csps;
+    int        done, count, i;
+
+    gotoACount = gotoBCount = doneCount = 0;
+
+    // Initialize GLFW
+    if( !glfwInit() )
+    {
+        return 0;
+    }
+
+    // Print some program information
+    printf( "\nMultithreading benchmarking program\n" );
+    printf( "-----------------------------------\n\n" );
+    printf( "This program consists of two tests. In the first test " );
+    printf( "two threads are created,\n" );
+    printf( "which continously signal/wait each other. This forces " );
+    printf( "the execution to\n" );
+    printf( "alternate between the two threads, and gives a measure " );
+    printf( "of the thread\n" );
+    printf( "synchronization granularity. In the second test, the " );
+    printf( "main thread is repeatedly\n" );
+    printf( "put to sleep for a very short interval using glfwSleep. " );
+    printf( "The average sleep time\n" );
+    printf( "is measured, which tells the minimum supported sleep " );
+    printf( "interval.\n\n" );
+    printf( "Results:\n" );
+    printf( "--------\n\n" );
+    printf( "Number of CPUs: %d\n\n", glfwGetNumberOfProcessors() );
+    fflush( stdout );
+
+
+//------------------------------------------------------------------------
+// 1) Benchmark thread synchronization granularity
+//------------------------------------------------------------------------
+
+    // Init mutexes and conditions
+    doneMutex  = glfwCreateMutex();
+    threadDone = glfwCreateCond();
+    InitSignal( &gotoA );
+    InitSignal( &gotoB );
+
+    // Create threads A & B
+    threadA = glfwCreateThread( &threadAfun, null );
+    threadB = glfwCreateThread( &threadBfun, null );
+    if( threadA == -1 || threadB == -1 )
+    {
+        glfwLockMutex( doneMutex );
+        doneCount = 2;
+        glfwUnlockMutex( doneMutex );
+    }
+
+    // Wait for both threads to be done
+    t1 = glfwGetTime();
+    glfwLockMutex( doneMutex );
+    do
+    {
+        done = (doneCount == 2);
+        if( !done )
+        {
+            glfwWaitCond( threadDone, doneMutex, GLFW_INFINITY );
+        }
+    }
+    while( !done );
+    glfwUnlockMutex( doneMutex );
+    t2 = glfwGetTime();
+
+    // Display results
+    count = gotoACount + gotoBCount;
+    csps = cast(double)count / (t2-t1);
+    printf( "Test 1:  %.0f context switches / second (%.3f us/switch)\n",
+            csps, 1e6/csps );
+    fflush( stdout );
+
+    // Wait for threads to die
+    glfwWaitThread( threadA, GLFW_WAIT );
+    glfwWaitThread( threadB, GLFW_WAIT );
+
+    // Destroy mutexes and conditions
+    glfwDestroyMutex( doneMutex );
+    glfwDestroyCond( threadDone );
+    KillSignal( &gotoA );
+    KillSignal( &gotoB );
+
+
+//------------------------------------------------------------------------
+// 2) Benchmark thread sleep granularity
+//------------------------------------------------------------------------
+
+    // Find an initial estimate
+    t1 = glfwGetTime();
+    for( i = 0; i < 10; i ++ )
+    {
+        glfwSleep( 0.0001 );
+    }
+    t2 = glfwGetTime();
+
+    // Sleep for roughly 1 s
+    count = cast(int)(1.0 / ((t2-t1)/10.0));
+    t1 = glfwGetTime();
+    for( i = 0; i < count; i ++ )
+    {
+        glfwSleep( 0.0001 );
+    }
+    t2 = glfwGetTime();
+
+    // Display results
+    printf( "Test 2:  %.3f ms / sleep (mean)\n\n",
+            1000.0 * (t2-t1) / cast(double)count );
+
+    // Terminate GLFW
+    glfwTerminate();
+
+    return 0;
+}
+
+
+version(Windows) {
+	extern(Windows):
+} else {
+	extern(C):
+}
+//------------------------------------------------------------------------
+// threadAfun()
+//------------------------------------------------------------------------
+
+void threadAfun( void * arg )
+{
+    int done;
+
+    do
+    {
+        done = (gotoACount >= MAX_COUNT);
+        if( !done )
+        {
+            gotoACount ++;
+            SetSignal( &gotoB );
+            WaitSignal( &gotoA );
+        }
+    }
+    while( !done );
+
+    SetSignal( &gotoB );
+
+    glfwLockMutex( doneMutex );
+    doneCount ++;
+    glfwUnlockMutex( doneMutex );
+    glfwSignalCond( threadDone );
+}
+
+
+//------------------------------------------------------------------------
+// threadBfun()
+//------------------------------------------------------------------------
+
+void threadBfun( void * arg )
+{
+    int done;
+
+    do
+    {
+        done = (gotoBCount >= MAX_COUNT);
+        if( !done )
+        {
+            gotoBCount ++;
+            SetSignal( &gotoA );
+            WaitSignal( &gotoB );
+        }
+    }
+    while( !done );
+
+    SetSignal( &gotoA );
+
+    glfwLockMutex( doneMutex );
+    doneCount ++;
+    glfwUnlockMutex( doneMutex );
+    glfwSignalCond( threadDone );
+}