ruby-glfw 0.9

data/glfw-src/examples/bundle.sh

@@ -0,0 +1,46 @@
+#!/bin/sh
+
+# Creates application bundles for use on Mac OS X.
+
+if [ -z "$1" ]; then
+  echo "usage: `basename $0` BUNDLE-NAME"
+  exit 1
+fi
+
+bundle_name="$1"
+
+if [ ! -d "${bundle_name}.app/Contents/MacOS" ]; then
+  mkdir -p "${bundle_name}.app/Contents/MacOS"
+fi
+
+if [ ! -d "${bundle_name}.app/Contents/Resources" ]; then
+  mkdir -p "${bundle_name}.app/Contents/Resources"
+fi
+
+if [ ! -f "${bundle_name}.app/Contents/PkgInfo" ]; then
+  echo -n "APPL????" > "${bundle_name}.app/Contents/PkgInfo"
+fi
+
+if [ ! -f "${bundle_name}.app/Contents/Info.plist" ]; then
+  cat > "${bundle_name}.app/Contents/Info.plist" <<EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+        <key>CFBundleDevelopmentRegion</key>
+        <string>English</string>
+        <key>CFBundleExecutable</key>
+        <string>${bundle_name}</string>
+        <key>CFBundleInfoDictionaryVersion</key>
+        <string>6.0</string>
+        <key>CFBundlePackageType</key>
+        <string>APPL</string>
+        <key>CFBundleSignature</key>
+        <string>????</string>
+        <key>CFBundleVersion</key>
+        <string>0.1</string>
+</dict>
+</plist>
+EOF
+fi
+

data/glfw-src/examples/gears.c

@@ -0,0 +1,382 @@
+/*
+ * 3-D gear wheels.  This program is in the public domain.
+ *
+ * Command line options:
+ *    -info      print GL implementation information
+ *    -exit      automatically exit after 30 seconds
+ *
+ *
+ * Brian Paul
+ *
+ *
+ * Marcus Geelnard:
+ *   - Conversion to GLFW
+ *   - Time based rendering (frame rate independent)
+ *   - Slightly modified camera that should work better for stereo viewing
+ */
+
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <GL/glfw.h>
+
+#ifndef M_PI
+#define M_PI 3.141592654
+#endif
+
+static int running = 1;
+static double t0 = 0.0;
+static double t;
+static double dt;
+
+static int Frames = 0;
+static int autoexit = 0;
+
+/**
+
+  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);
+
+  /* draw front face */
+  glBegin(GL_QUAD_STRIP);
+  for (i = 0; i <= teeth; i++) {
+    angle = i * 2.0 * M_PI / teeth;
+    glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
+    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
+    if (i < teeth) {
+      glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
+      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;
+
+    glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
+    glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
+    glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
+    glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
+  }
+  glEnd();
+
+  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 GLfloat view_rotx = 20.0, view_roty = 30.0, view_rotz = 0.0;
+static GLint gear1, gear2, gear3;
+static GLfloat angle = 0.0;
+
+/* OpenGL draw function & timing */
+static void draw(void)
+{
+  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);
+      glCallList(gear1);
+    glPopMatrix();
+
+    glPushMatrix();
+      glTranslatef(3.1, -2.0, 0.0);
+      glRotatef(-2.0 * angle - 9.0, 0.0, 0.0, 1.0);
+      glCallList(gear2);
+    glPopMatrix();
+
+    glPushMatrix();
+      glTranslatef(-3.1, 4.2, 0.0);
+      glRotatef(-2.0 * angle - 25.0, 0.0, 0.0, 1.0);
+      glCallList(gear3);
+    glPopMatrix();
+
+  glPopMatrix();
+
+  Frames++;
+
+  {
+     double t_new = glfwGetTime();
+     dt = t_new - t;
+     t = t_new;
+
+     if (t - t0 >= 5.0)
+     {
+        double seconds = t - t0;
+        double fps = Frames / seconds;
+        printf("%d frames in %6.3f seconds = %6.3f FPS\n", Frames, seconds, fps);
+        t0 = t;
+        Frames = 0;
+        if ((t >= 0.999 * autoexit) && (autoexit))
+        {
+           running = 0;
+        }
+     }
+  }
+}
+
+
+/* update animation parameters */
+static void animate(void)
+{
+  angle += 100.0*dt;
+}
+
+
+/* change view angle, exit upon ESC */
+void GLFWCALL key( int k, int action )
+{
+  if( action != GLFW_PRESS ) return;
+
+  switch (k) {
+  case 'Z':
+    if( glfwGetKey( GLFW_KEY_LSHIFT ) )
+      view_rotz -= 5.0;
+    else
+      view_rotz += 5.0;
+    break;
+  case GLFW_KEY_ESC:
+    running = 0;
+    break;
+  case GLFW_KEY_UP:
+    view_rotx += 5.0;
+    break;
+  case GLFW_KEY_DOWN:
+    view_rotx -= 5.0;
+    break;
+  case GLFW_KEY_LEFT:
+    view_roty += 5.0;
+    break;
+  case GLFW_KEY_RIGHT:
+    view_roty -= 5.0;
+    break;
+  default:
+    return;
+  }
+}
+
+
+/* new window size */
+void GLFWCALL reshape( int width, int height )
+{
+  GLfloat h = (GLfloat) height / (GLfloat) width;
+  GLfloat xmax, znear, zfar;
+
+  znear = 5.0f;
+  zfar  = 30.0f;
+  xmax  = znear * 0.5;
+
+  glViewport( 0, 0, (GLint) width, (GLint) height );
+  glMatrixMode( GL_PROJECTION );
+  glLoadIdentity();
+  glFrustum( -xmax, xmax, -xmax*h, xmax*h, znear, zfar );
+  glMatrixMode( GL_MODELVIEW );
+  glLoadIdentity();
+  glTranslatef( 0.0, 0.0, -20.0 );
+}
+
+
+/* program & OpenGL initialization */
+static void init(int argc, char *argv[])
+{
+  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};
+  GLint i;
+
+  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();
+
+  glEnable(GL_NORMALIZE);
+
+  for ( i=1; i<argc; i++ ) {
+    if (strcmp(argv[i], "-info")==0) {
+      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));
+    }
+    else if ( strcmp(argv[i], "-exit")==0) {
+      autoexit = 30;
+      printf("Auto Exit after %i seconds.\n", autoexit );
+    }
+  }
+}
+
+
+/* program entry */
+int main(int argc, char *argv[])
+{
+    // Init GLFW and open window
+    glfwInit();
+    if( !glfwOpenWindow( 300,300, 0,0,0,0, 16,0, GLFW_WINDOW ) )
+    {
+        glfwTerminate();
+        return 0;
+    }
+    glfwSetWindowTitle( "Gears" );
+    glfwEnable( GLFW_KEY_REPEAT );
+    glfwSwapInterval( 0 );
+
+    // Special args?
+    init(argc, argv);
+
+    // Set callback functions
+    glfwSetWindowSizeCallback( reshape );
+    glfwSetKeyCallback( key );
+
+    // Main loop
+    while( running )
+    {
+        // Draw gears
+        draw();
+
+        // Update animation
+        animate();
+
+        // Swap buffers
+        glfwSwapBuffers();
+
+        // Was the window closed?
+        if( !glfwGetWindowParam( GLFW_OPENED ) )
+        {
+            running = 0;
+        }
+    }
+
+    // Terminate GLFW
+    glfwTerminate();
+
+    // Exit program
+    return 0;
+}

data/glfw-src/examples/keytest.c

@@ -0,0 +1,264 @@
+//========================================================================
+// This is a small test application for GLFW.
+// Keyboard input test.
+//========================================================================
+
+#include <stdio.h>
+#include <math.h>
+#include <GL/glfw.h>
+
+int running;
+int keyrepeat  = 0;
+int systemkeys = 1;
+
+
+//========================================================================
+// keyfun()
+//========================================================================
+
+void GLFWCALL keyfun( int key, int action )
+{
+    if( action != GLFW_PRESS )
+    {
+        return;
+    }
+
+    switch( key )
+    {
+    case GLFW_KEY_ESC:
+        printf( "ESC => quit program\n" );
+        running = GL_FALSE;
+        break;
+    case GLFW_KEY_F1:
+    case GLFW_KEY_F2:
+    case GLFW_KEY_F3:
+    case GLFW_KEY_F4:
+    case GLFW_KEY_F5:
+    case GLFW_KEY_F6:
+    case GLFW_KEY_F7:
+    case GLFW_KEY_F8:
+    case GLFW_KEY_F9:
+    case GLFW_KEY_F10:
+    case GLFW_KEY_F11:
+    case GLFW_KEY_F12:
+    case GLFW_KEY_F13:
+    case GLFW_KEY_F14:
+    case GLFW_KEY_F15:
+    case GLFW_KEY_F16:
+    case GLFW_KEY_F17:
+    case GLFW_KEY_F18:
+    case GLFW_KEY_F19:
+    case GLFW_KEY_F20:
+    case GLFW_KEY_F21:
+    case GLFW_KEY_F22:
+    case GLFW_KEY_F23:
+    case GLFW_KEY_F24:
+    case GLFW_KEY_F25:
+        printf( "F%d\n", 1 + key - GLFW_KEY_F1 );
+        break;
+    case GLFW_KEY_UP:
+        printf( "UP\n" );
+        break;
+    case GLFW_KEY_DOWN:
+        printf( "DOWN\n" );
+        break;
+    case GLFW_KEY_LEFT:
+        printf( "LEFT\n" );
+        break;
+    case GLFW_KEY_RIGHT:
+        printf( "RIGHT\n" );
+        break;
+    case GLFW_KEY_LSHIFT:
+        printf( "LSHIFT\n" );
+        break;
+    case GLFW_KEY_RSHIFT:
+        printf( "RSHIFT\n" );
+        break;
+    case GLFW_KEY_LCTRL:
+        printf( "LCTRL\n" );
+        break;
+    case GLFW_KEY_RCTRL:
+        printf( "RCTRL\n" );
+        break;
+    case GLFW_KEY_LALT:
+        printf( "LALT\n" );
+        break;
+    case GLFW_KEY_RALT:
+        printf( "RALT\n" );
+        break;
+    case GLFW_KEY_TAB:
+        printf( "TAB\n" );
+        break;
+    case GLFW_KEY_ENTER:
+        printf( "ENTER\n" );
+        break;
+    case GLFW_KEY_BACKSPACE:
+        printf( "BACKSPACE\n" );
+        break;
+    case GLFW_KEY_INSERT:
+        printf( "INSERT\n" );
+        break;
+    case GLFW_KEY_DEL:
+        printf( "DEL\n" );
+        break;
+    case GLFW_KEY_PAGEUP:
+        printf( "PAGEUP\n" );
+        break;
+    case GLFW_KEY_PAGEDOWN:
+        printf( "PAGEDOWN\n" );
+        break;
+    case GLFW_KEY_HOME:
+        printf( "HOME\n" );
+        break;
+    case GLFW_KEY_END:
+        printf( "END\n" );
+        break;
+    case GLFW_KEY_KP_0:
+        printf( "KEYPAD 0\n" );
+        break;
+    case GLFW_KEY_KP_1:
+        printf( "KEYPAD 1\n" );
+        break;
+    case GLFW_KEY_KP_2:
+        printf( "KEYPAD 2\n" );
+        break;
+    case GLFW_KEY_KP_3:
+        printf( "KEYPAD 3\n" );
+        break;
+    case GLFW_KEY_KP_4:
+        printf( "KEYPAD 4\n" );
+        break;
+    case GLFW_KEY_KP_5:
+        printf( "KEYPAD 5\n" );
+        break;
+    case GLFW_KEY_KP_6:
+        printf( "KEYPAD 6\n" );
+        break;
+    case GLFW_KEY_KP_7:
+        printf( "KEYPAD 7\n" );
+        break;
+    case GLFW_KEY_KP_8:
+        printf( "KEYPAD 8\n" );
+        break;
+    case GLFW_KEY_KP_9:
+        printf( "KEYPAD 9\n" );
+        break;
+    case GLFW_KEY_KP_DIVIDE:
+        printf( "KEYPAD DIVIDE\n" );
+        break;
+    case GLFW_KEY_KP_MULTIPLY:
+        printf( "KEYPAD MULTIPLY\n" );
+        break;
+    case GLFW_KEY_KP_SUBTRACT:
+        printf( "KEYPAD SUBTRACT\n" );
+        break;
+    case GLFW_KEY_KP_ADD:
+        printf( "KEYPAD ADD\n" );
+        break;
+    case GLFW_KEY_KP_DECIMAL:
+        printf( "KEYPAD DECIMAL\n" );
+        break;
+    case GLFW_KEY_KP_EQUAL:
+        printf( "KEYPAD =\n" );
+        break;
+    case GLFW_KEY_KP_ENTER:
+        printf( "KEYPAD ENTER\n" );
+        break;
+    case GLFW_KEY_SPACE:
+        printf( "SPACE\n" );
+        break;
+    case 'R':
+        keyrepeat = (keyrepeat+1) & 1;
+        if( keyrepeat )
+        {
+            glfwEnable( GLFW_KEY_REPEAT );
+        }
+        else
+        {
+            glfwDisable( GLFW_KEY_REPEAT );
+        }
+        printf( "R => Key repeat: %s\n", keyrepeat ? "ON" : "OFF" );
+        break;
+    case 'S':
+        systemkeys = (systemkeys+1) & 1;
+        if( systemkeys )
+        {
+            glfwEnable( GLFW_SYSTEM_KEYS );
+        }
+        else
+        {
+            glfwDisable( GLFW_SYSTEM_KEYS );
+        }
+        printf( "S => System keys: %s\n", systemkeys ? "ON" : "OFF" );
+        break;
+    default:
+        if( key > 0 && key < 256 )
+        {
+            printf( "%c\n", (char) key );
+        }
+        else
+        {
+            printf( "???\n" );
+        }
+        break;
+    }
+
+    fflush( stdout );
+}
+
+
+//========================================================================
+// main()
+//========================================================================
+
+int main( void )
+{
+    int     width, height;
+    double  t;
+
+    // Initialise GLFW
+    glfwInit();
+
+    // Open OpenGL window
+    if( !glfwOpenWindow( 250,100, 0,0,0,0, 0,0, GLFW_WINDOW ) )
+    {
+        glfwTerminate();
+        return 0;
+    }
+
+    // Set key callback function
+    glfwSetKeyCallback( keyfun );
+
+    // Set tile
+    glfwSetWindowTitle( "Press some keys!" );
+
+    // Main loop
+    running = GL_TRUE;
+    while( running )
+    {
+        // Get time and mouse position
+        t = glfwGetTime();
+
+        // 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( (GLfloat)(0.5+0.5*sin(3.0*t)), 0.0f, 0.0f, 0.0f);
+        glClear( GL_COLOR_BUFFER_BIT );
+
+        // Swap buffers
+        glfwSwapBuffers();
+
+        // Check if the window was closed
+        running = running && glfwGetWindowParam( GLFW_OPENED );
+    }
+
+    // Close OpenGL window and terminate GLFW
+    glfwTerminate();
+
+    return 0;
+}