ruby-glfw 0.9

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

@@ -0,0 +1,54 @@
+//========================================================================
+// This is a small test application for GLFW.
+// The program prints "Hello world!", using two threads.
+//========================================================================
+
+import glfw;
+
+
+//========================================================================
+// main() - Main function (main thread)
+//========================================================================
+
+int main( )
+{
+    GLFWthread thread;
+
+    // Initialise GLFW
+    if( !glfwInit() )
+    {
+        return 0;
+    }
+
+    // Create thread
+    thread = glfwCreateThread( &HelloFun, null );
+
+    // Wait for thread to die
+    glfwWaitThread( thread, GLFW_WAIT );
+
+    // Print the rest of the message
+    printf( "world!\n" );
+
+    // Terminate GLFW
+    glfwTerminate();
+
+    return 0;
+}
+
+version(Windows) {
+	extern(Windows):
+} else {
+	extern(C):
+}
+
+//========================================================================
+// HelloFun() - Thread function
+//========================================================================
+
+void HelloFun( void *arg )
+{
+    // Print the first part of the message
+    printf( "Hello " );
+}
+
+

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

@@ -0,0 +1,1150 @@
+//========================================================================
+// This is a simple, but cool particle engine (buzz-word meaning many
+// small objects that are treated as points and drawn as textures
+// projected on simple geometry).
+//
+// This demonstration generates a colorful fountain-like animation. It
+// uses several advanced OpenGL teqhniques:
+//
+//  1) Lighting (per vertex)
+//  2) Alpha blending
+//  3) Fog
+//  4) Texturing
+//  5) Display lists (for drawing the static environment geometry)
+//  6) Vertex arrays (for drawing the particles)
+//  7) GL_EXT_separate_specular_color is used (if available)
+//
+// Even more so, this program uses multi threading. The program is
+// essentialy divided into a main rendering thread and a particle physics
+// calculation thread. My benchmarks under Windows 2000 on a single
+// processor system show that running this program as two threads instead
+// of a single thread means no difference (there may be a very marginal
+// advantage for the multi threaded case). On dual processor systems I
+// have had reports of 5-25% of speed increase when running this program
+// as two threads instead of one thread.
+//
+// The default behaviour of this program is to use two threads. To force
+// a single thread to be used, use the command line switch -s.
+//
+// To run a fixed length benchmark (60 s), use the command line switch -b.
+//
+// Benchmark results (640x480x16, best of three tests):
+//
+//  CPU               GFX                   1 thread      2 threads
+//  Athlon XP 2700+   GeForce Ti4200 (oc)    757 FPS        759 FPS
+//  P4 2.8 GHz (SMT)  GeForce FX5600         548 FPS        550 FPS
+//
+// One more thing: Press 'w' during the demo to toggle wireframe mode.
+//========================================================================
+
+import std.math;
+import std.c.string;
+import std.random;
+import glfw;
+
+// Define tokens for GL_EXT_separate_specular_color if not already defined
+// #ifndef GL_EXT_separate_specular_color
+const int GL_LIGHT_MODEL_COLOR_CONTROL_EXT  = 0x81F8;
+const int GL_SINGLE_COLOR_EXT               = 0x81F9;
+const int GL_SEPARATE_SPECULAR_COLOR_EXT    = 0x81FA;
+// #endif // GL_EXT_separate_specular_color
+
+// Desired fullscreen resolution
+const int WIDTH  = 640;
+const int HEIGHT = 480;
+
+
+//========================================================================
+// Type definitions
+//========================================================================
+
+struct VEC { float x,y,z; }
+
+// This structure is used for interleaved vertex arrays (see the
+// DrawParticles function) - Note: This structure SHOULD be packed on most
+// systems. It uses 32-bit fields on 32-bit boundaries, and is a multiple
+// of 64 bits in total (6x32=3x64). If it does not work, try using pragmas
+// or whatever to force the structure to be packed.
+struct VERTEX {
+    GLfloat s, t;         // Texture coordinates
+    GLuint  rgba;         // Color (four ubytes packed into an uint)
+    GLfloat x, y, z;      // Vertex coordinates
+}
+
+
+//========================================================================
+// Program control global variables
+//========================================================================
+
+// "Running" flag (true if program shall continue to run)
+int running = 0;
+
+// Window dimensions
+int width=640, height=480;
+
+// "wireframe" flag (true if we use wireframe view)
+int wireframe = 0;
+
+// "multithreading" flag (true if we use multithreading)
+int multithreading = 0;
+
+// Thread synchronization
+struct TS {
+    double    t;         // Time (s)
+    float     dt;        // Time since last frame (s)
+    int       p_frame;   // Particle physics frame number
+    int       d_frame;   // Particle draw frame number
+    GLFWcond  p_done;    // Condition: particle physics done
+    GLFWcond  d_done;    // Condition: particle draw done
+    GLFWmutex particles_lock; // Particles data sharing mutex
+}
+TS thread_sync;
+
+
+//========================================================================
+// Texture declarations (we hard-code them into the source code, since
+// they are so simple)
+//========================================================================
+
+const int P_TEX_WIDTH  =  8;   // Particle texture dimensions
+const int P_TEX_HEIGHT =  8;
+const int F_TEX_WIDTH  = 16;   // Floor texture dimensions
+const int F_TEX_HEIGHT = 16;
+
+// Texture object IDs
+GLuint particle_tex_id=0, floor_tex_id=0;
+
+// Particle texture (a simple spot)
+const ubyte[ P_TEX_WIDTH * P_TEX_HEIGHT ] particle_texture = [
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x11, 0x22, 0x22, 0x11, 0x00, 0x00,
+    0x00, 0x11, 0x33, 0x88, 0x77, 0x33, 0x11, 0x00,
+    0x00, 0x22, 0x88, 0xff, 0xee, 0x77, 0x22, 0x00,
+    0x00, 0x22, 0x77, 0xee, 0xff, 0x88, 0x22, 0x00,
+    0x00, 0x11, 0x33, 0x77, 0x88, 0x33, 0x11, 0x00,
+    0x00, 0x00, 0x11, 0x33, 0x22, 0x11, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+];
+
+// Floor texture (your basic checkered floor)
+const ubyte[ F_TEX_WIDTH * F_TEX_HEIGHT ] floor_texture = [
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+    0xff, 0xf0, 0xcc, 0xf0, 0xf0, 0xf0, 0xff, 0xf0, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+    0xf0, 0xcc, 0xee, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 0x30, 0x66, 0x30, 0x30, 0x30, 0x20, 0x30, 0x30,
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xee, 0xf0, 0xf0, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+    0xf0, 0xf0, 0xf0, 0xf0, 0xcc, 0xf0, 0xf0, 0xf0, 0x30, 0x30, 0x55, 0x30, 0x30, 0x44, 0x30, 0x30,
+    0xf0, 0xdd, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xf0, 0xf0, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x60, 0x30,
+    0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x33, 0x33, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
+    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x33, 0x30, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+    0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x30, 0x30, 0xf0, 0xff, 0xf0, 0xf0, 0xdd, 0xf0, 0xf0, 0xff,
+    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x55, 0x33, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xff, 0xf0, 0xf0,
+    0x30, 0x44, 0x66, 0x30, 0x30, 0x30, 0x30, 0x30, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0xf0, 0xf0, 0xf0, 0xaa, 0xf0, 0xf0, 0xcc, 0xf0,
+    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0xff, 0xf0, 0xf0, 0xf0, 0xff, 0xf0, 0xdd, 0xf0,
+    0x30, 0x30, 0x30, 0x77, 0x30, 0x30, 0x30, 0x30, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+    0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0,
+];
+
+
+//========================================================================
+// These are fixed constants that control the particle engine. In a
+// modular world, these values should be variables...
+//========================================================================
+
+// Maximum number of particles
+const int MAX_PARTICLES   = 3000;
+
+// Life span of a particle (in seconds)
+const float LIFE_SPAN       = 8.0f;
+
+// A new particle is born every [BIRTH_INTERVAL] second
+const float BIRTH_INTERVAL = (LIFE_SPAN/cast(float)MAX_PARTICLES);
+
+// Particle size (meters)
+const float PARTICLE_SIZE   = 0.7f;
+
+// Gravitational constant (m/s^2)
+const float GRAVITY         = 9.8f;
+
+// Base initial velocity (m/s)
+const float VELOCITY        = 8.0f;
+
+// Bounce friction (1.0 = no friction, 0.0 = maximum friction)
+const float FRICTION        = 0.75f;
+
+// "Fountain" height (m)
+const float FOUNTAIN_HEIGHT = 3.0f;
+
+// Fountain radius (m)
+const float FOUNTAIN_RADIUS = 1.6f;
+
+// Minimum delta-time for particle phisics (s)
+const float MIN_DELTA_T     = (BIRTH_INTERVAL*0.5);
+
+
+//========================================================================
+// Particle system global variables
+//========================================================================
+
+// This structure holds all state for a single particle
+struct PARTICLE {
+    float x,y,z;     // Position in space
+    float vx,vy,vz;  // Velocity vector
+    float r,g,b;     // Color of particle
+    float life;      // Life of particle (1.0 = newborn, < 0.0 = dead)
+    int   active;    // Tells if this particle is active
+}
+
+// Global vectors holding all particles. We use two vectors for double
+// buffering.
+static PARTICLE[ MAX_PARTICLES ] particles;
+
+// Global variable holding the age of the youngest particle
+static float min_age = 0.0;
+
+// Color of latest born particle (used for fountain lighting)
+static float[4] glow_color = [0.0, 0.0, 0.0, 0.0];
+
+// Position of latest born particle (used for fountain lighting)
+static float[4] glow_pos = [0.0, 0.0, 0.0, 0.0];
+
+
+//========================================================================
+// Object material and fog configuration constants
+//========================================================================
+
+const GLfloat[4] fountain_diffuse     = [0.7f,1.0f,1.0f,1.0f];
+const GLfloat[4] fountain_specular    = [1.0f,1.0f,1.0f,1.0f];
+const GLfloat    fountain_shininess   = 12.0f;
+const GLfloat[4] floor_diffuse        = [1.0f,0.6f,0.6f,1.0f];
+const GLfloat[4] floor_specular       = [0.6f,0.6f,0.6f,1.0f];
+const GLfloat    floor_shininess      = 18.0f;
+const GLfloat[4] fog_color            = [0.1f, 0.1f, 0.1f, 1.0f];
+
+
+//========================================================================
+// InitParticle() - Initialize a new particle
+//========================================================================
+
+void InitParticle( PARTICLE* p, double t )
+{
+    float   xy_angle=0.0, velocity=0.0;
+
+    // Start position of particle is at the fountain blow-out
+    p.x = 0.0f;
+    p.y = 0.0f;
+    p.z = FOUNTAIN_HEIGHT;
+
+    // Start velocity is up (Z)...
+    p.vz = 0.7f + (0.3/4096.0) * cast(float) (rand() & 4095);
+
+    // ...and a randomly chosen X/Y direction
+    xy_angle = (2.0*PI/4096.0) * cast(float) (rand() & 4095);
+    p.vx = 0.4f * cast(float) cos( xy_angle );
+    p.vy = 0.4f * cast(float) sin( xy_angle );
+
+    // Scale velocity vector according to a time-varying velocity
+    velocity = VELOCITY*(0.8f + 0.1f*cast(float)(sin( 0.5*t )+sin( 1.31*t )));
+    p.vx *= velocity;
+    p.vy *= velocity;
+    p.vz *= velocity;
+
+    // Color is time-varying
+    p.r = 0.7f + 0.3f * cast(float) sin( 0.34*t + 0.1 );
+    p.g = 0.6f + 0.4f * cast(float) sin( 0.63*t + 1.1 );
+    p.b = 0.6f + 0.4f * cast(float) sin( 0.91*t + 2.1 );
+
+    // Store settings for fountain glow lighting
+    glow_pos[0] = 0.4f * cast(float) sin( 1.34*t );
+    glow_pos[1] = 0.4f * cast(float) sin( 3.11*t );
+    glow_pos[2] = FOUNTAIN_HEIGHT + 1.0f;
+    glow_pos[3] = 1.0f;
+    glow_color[0] = p.r;
+    glow_color[1] = p.g;
+    glow_color[2] = p.b;
+    glow_color[3] = 1.0f;
+
+    // The particle is new-born and active
+    p.life = 1.0f;
+    p.active = 1;
+}
+
+
+//========================================================================
+// UpdateParticle() - Update a particle
+//========================================================================
+
+const float FOUNTAIN_R2 = (FOUNTAIN_RADIUS+PARTICLE_SIZE/2) * (FOUNTAIN_RADIUS+PARTICLE_SIZE/2);
+
+void UpdateParticle( PARTICLE* p, float dt )
+{
+    // If the particle is not active, we need not do anything
+    if( !p.active )
+    {
+        return;
+    }
+
+    // The particle is getting older...
+    p.life = p.life - dt * (1.0f / LIFE_SPAN);
+
+    // Did the particle die?
+    if( p.life <= 0.0f )
+    {
+        p.active = 0;
+        return;
+    }
+
+    // Update particle velocity (apply gravity)
+    p.vz = p.vz - GRAVITY * dt;
+
+    // Update particle position
+    p.x = p.x + p.vx * dt;
+    p.y = p.y + p.vy * dt;
+    p.z = p.z + p.vz * dt;
+
+    // Simple collision detection + response
+    if( p.vz < 0.0f )
+    {
+        // Particles should bounce on the fountain (with friction)
+        if( (p.x*p.x + p.y*p.y) < FOUNTAIN_R2 &&
+            p.z < (FOUNTAIN_HEIGHT + PARTICLE_SIZE/2) )
+        {
+            p.vz = -FRICTION * p.vz;
+            p.z  = FOUNTAIN_HEIGHT + PARTICLE_SIZE/2 +
+                        FRICTION * (FOUNTAIN_HEIGHT +
+                        PARTICLE_SIZE/2 - p.z);
+        }
+
+        // Particles should bounce on the floor (with friction)
+        else if( p.z < PARTICLE_SIZE/2 )
+        {
+            p.vz = -FRICTION * p.vz;
+            p.z  = PARTICLE_SIZE/2 +
+                        FRICTION * (PARTICLE_SIZE/2 - p.z);
+        }
+
+    }
+}
+
+
+//========================================================================
+// ParticleEngine() - The main frame for the particle engine. Called once
+// per frame.
+//========================================================================
+
+void ParticleEngine( double t, float dt )
+{
+    int      i;
+    float    dt2 = 0.0;
+
+    // Update particles (iterated several times per frame if dt is too
+    // large)
+    while( dt > 0.0f )
+    {
+        // Calculate delta time for this iteration
+        dt2 = dt < MIN_DELTA_T ? dt : MIN_DELTA_T;
+
+        // Update particles
+        for( i = 0; i < MAX_PARTICLES; i ++ )
+        {
+            UpdateParticle( &particles[ i ], dt2 );
+        }
+
+        // Increase minimum age
+        min_age += dt2;
+
+        // Should we create any new particle(s)?
+        while( min_age >= BIRTH_INTERVAL )
+        {
+            min_age -= BIRTH_INTERVAL;
+
+            // Find a dead particle to replace with a new one
+            for( i = 0; i < MAX_PARTICLES; i ++ )
+            {
+                if( !particles[ i ].active )
+                {
+                    InitParticle( &particles[ i ], t + min_age );
+                    UpdateParticle( &particles[ i ], min_age );
+                    break;
+                }
+            }
+        }
+
+        // Decrease frame delta time
+        dt -= dt2;
+    }
+}
+
+
+//========================================================================
+// DrawParticles() - Draw all active particles. We use OpenGL 1.1 vertex
+// arrays for this in order to accelerate the drawing.
+//========================================================================
+
+const int BATCH_PARTICLES = 70;  // Number of particles to draw in each batch
+                                 // (70 corresponds to 7.5 KB = will not blow
+                                 // the L1 data cache on most CPUs)
+const int PARTICLE_VERTS  =  4;  // Number of vertices per particle
+
+void DrawParticles( double t, float dt )
+{
+    int       i = 0, particle_count = 0;
+    VERTEX[ BATCH_PARTICLES * PARTICLE_VERTS ] vertex_array;
+    VERTEX    *vptr;
+    float     alpha = 0.0;
+    GLuint    rgba;
+    VEC       quad_lower_left, quad_lower_right;
+    GLfloat   mat[ 16 ];
+    PARTICLE  *pptr;
+
+    // Here comes the real trick with flat single primitive objects (s.c.
+    // "billboards"): We must rotate the textured primitive so that it
+    // always faces the viewer (is coplanar with the view-plane).
+    // We:
+    //   1) Create the primitive around origo (0,0,0)
+    //   2) Rotate it so that it is coplanar with the view plane
+    //   3) Translate it according to the particle position
+    // Note that 1) and 2) is the same for all particles (done only once).
+
+    // Get modelview matrix. We will only use the upper left 3x3 part of
+    // the matrix, which represents the rotation.
+    glGetFloatv( GL_MODELVIEW_MATRIX, mat );
+
+    // 1) & 2) We do it in one swift step:
+    // Although not obvious, the following six lines represent two matrix/
+    // vector multiplications. The matrix is the inverse 3x3 rotation
+    // matrix (i.e. the transpose of the same matrix), and the two vectors
+    // represent the lower left corner of the quad, PARTICLE_SIZE/2 *
+    // (-1,-1,0), and the lower right corner, PARTICLE_SIZE/2 * (1,-1,0).
+    // The upper left/right corners of the quad is always the negative of
+    // the opposite corners (regardless of rotation).
+    quad_lower_left.x = (-PARTICLE_SIZE/2) * (mat[0] + mat[1]);
+    quad_lower_left.y = (-PARTICLE_SIZE/2) * (mat[4] + mat[5]);
+    quad_lower_left.z = (-PARTICLE_SIZE/2) * (mat[8] + mat[9]);
+    quad_lower_right.x = (PARTICLE_SIZE/2) * (mat[0] - mat[1]);
+    quad_lower_right.y = (PARTICLE_SIZE/2) * (mat[4] - mat[5]);
+    quad_lower_right.z = (PARTICLE_SIZE/2) * (mat[8] - mat[9]);
+
+    // Don't update z-buffer, since all particles are transparent!
+    glDepthMask( GL_FALSE );
+
+    // Enable blending
+    glEnable( GL_BLEND );
+    glBlendFunc( GL_SRC_ALPHA, GL_ONE );
+
+    // Select particle texture
+    if( !wireframe )
+    {
+        glEnable( GL_TEXTURE_2D );
+        glBindTexture( GL_TEXTURE_2D, particle_tex_id );
+    }
+
+    // Set up vertex arrays. We use interleaved arrays, which is easier to
+    // handle (in most situations) and it gives a linear memeory access
+    // access pattern (which may give better performance in some
+    // situations). GL_T2F_C4UB_V3F means: 2 floats for texture coords,
+    // 4 ubytes for color and 3 floats for vertex coord (in that order).
+    // Most OpenGL cards / drivers are optimized for this format.
+    glInterleavedArrays( GL_T2F_C4UB_V3F, 0, vertex_array );
+
+    // Is particle physics carried out in a separate thread?
+    if( multithreading )
+    {
+        // Wait for particle physics thread to be done
+        glfwLockMutex( thread_sync.particles_lock );
+        while( running && thread_sync.p_frame <= thread_sync.d_frame )
+        {
+            glfwWaitCond( thread_sync.p_done, thread_sync.particles_lock,
+                          0.1 );
+        }
+
+        // Store the frame time and delta time for the physics thread
+        thread_sync.t  = t;
+        thread_sync.dt = dt;
+
+        // Update frame counter
+        thread_sync.d_frame ++;
+    }
+    else
+    {
+        // Perform particle physics in this thread
+        ParticleEngine( t, dt );
+    }
+
+    // Loop through all particles and build vertex arrays.
+    particle_count = 0;
+    vptr = vertex_array;
+    pptr = particles;
+    for( i = 0; i < MAX_PARTICLES; i ++ )
+    {
+        if( pptr.active )
+        {
+            // Calculate particle intensity (we set it to max during 75%
+            // of its life, then it fades out)
+            alpha =  4.0f * pptr.life;
+            if( alpha > 1.0f )
+            {
+                alpha = 1.0f;
+            }
+
+            // Convert color from float to 8-bit (store it in a 32-bit
+            // integer using endian independent type casting)
+            (cast(GLubyte *)&rgba)[0] = cast(GLubyte)(pptr.r * 255.0f);
+            (cast(GLubyte *)&rgba)[1] = cast(GLubyte)(pptr.g * 255.0f);
+            (cast(GLubyte *)&rgba)[2] = cast(GLubyte)(pptr.b * 255.0f);
+            (cast(GLubyte *)&rgba)[3] = cast(GLubyte)(alpha * 255.0f);
+
+            // 3) Translate the quad to the correct position in modelview
+            // space and store its parameters in vertex arrays (we also
+            // store texture coord and color information for each vertex).
+
+            // Lower left corner
+            vptr.s    = 0.0f;
+            vptr.t    = 0.0f;
+            vptr.rgba = rgba;
+            vptr.x    = pptr.x + quad_lower_left.x;
+            vptr.y    = pptr.y + quad_lower_left.y;
+            vptr.z    = pptr.z + quad_lower_left.z;
+            vptr ++;
+
+            // Lower right corner
+            vptr.s    = 1.0f;
+            vptr.t    = 0.0f;
+            vptr.rgba = rgba;
+            vptr.x    = pptr.x + quad_lower_right.x;
+            vptr.y    = pptr.y + quad_lower_right.y;
+            vptr.z    = pptr.z + quad_lower_right.z;
+            vptr ++;
+
+            // Upper right corner
+            vptr.s    = 1.0f;
+            vptr.t    = 1.0f;
+            vptr.rgba = rgba;
+            vptr.x    = pptr.x - quad_lower_left.x;
+            vptr.y    = pptr.y - quad_lower_left.y;
+            vptr.z    = pptr.z - quad_lower_left.z;
+            vptr ++;
+
+            // Upper left corner
+            vptr.s    = 0.0f;
+            vptr.t    = 1.0f;
+            vptr.rgba = rgba;
+            vptr.x    = pptr.x - quad_lower_right.x;
+            vptr.y    = pptr.y - quad_lower_right.y;
+            vptr.z    = pptr.z - quad_lower_right.z;
+            vptr ++;
+
+            // Increase count of drawable particles
+            particle_count ++;
+        }
+
+        // If we have filled up one batch of particles, draw it as a set
+        // of quads using glDrawArrays.
+        if( particle_count >= BATCH_PARTICLES )
+        {
+            // The first argument tells which primitive type we use (QUAD)
+            // The second argument tells the index of the first vertex (0)
+            // The last argument is the vertex count
+            glDrawArrays( GL_QUADS, 0, PARTICLE_VERTS * particle_count );
+            particle_count = 0;
+            vptr = vertex_array;
+        }
+
+        // Next particle
+        pptr ++;
+    }
+
+    // We are done with the particle data: Unlock mutex and signal physics
+    // thread
+    if( multithreading )
+    {
+        glfwUnlockMutex( thread_sync.particles_lock );
+        glfwSignalCond( thread_sync.d_done );
+    }
+
+    // Draw final batch of particles (if any)
+    glDrawArrays( GL_QUADS, 0, PARTICLE_VERTS * particle_count );
+
+    // Disable vertex arrays (Note: glInterleavedArrays implicitly called
+    // glEnableClientState for vertex, texture coord and color arrays)
+    glDisableClientState( GL_VERTEX_ARRAY );
+    glDisableClientState( GL_TEXTURE_COORD_ARRAY );
+    glDisableClientState( GL_COLOR_ARRAY );
+
+    // Disable texturing and blending
+    glDisable( GL_TEXTURE_2D );
+    glDisable( GL_BLEND );
+
+    // Allow Z-buffer updates again
+    glDepthMask( GL_TRUE );
+}
+
+
+//========================================================================
+// Fountain geometry specification
+//========================================================================
+
+const int FOUNTAIN_SIDE_POINTS = 14;
+const int FOUNTAIN_SWEEP_STEPS = 32;
+
+static const float[ FOUNTAIN_SIDE_POINTS*2 ] fountain_side = [
+    1.2f, 0.0f,  1.0f, 0.2f,  0.41f, 0.3f, 0.4f, 0.35f,
+    0.4f, 1.95f, 0.41f, 2.0f, 0.8f, 2.2f,  1.2f, 2.4f,
+    1.5f, 2.7f,  1.55f,2.95f, 1.6f, 3.0f,  1.0f, 3.0f,
+    0.5f, 3.0f,  0.0f, 3.0f
+];
+
+static const float[ FOUNTAIN_SIDE_POINTS*2 ] fountain_normal = [
+    1.0000f, 0.0000f,  0.6428f, 0.7660f,  0.3420f, 0.9397f,  1.0000f, 0.0000f,
+    1.0000f, 0.0000f,  0.3420f,-0.9397f,  0.4226f,-0.9063f,  0.5000f,-0.8660f,
+    0.7660f,-0.6428f,  0.9063f,-0.4226f,  0.0000f,1.00000f,  0.0000f,1.00000f,
+    0.0000f,1.00000f,  0.0000f,1.00000f
+];
+
+
+//========================================================================
+// DrawFountain() - Draw a fountain
+//========================================================================
+
+void DrawFountain()
+{
+    static GLuint fountain_list = 0;
+    double angle = 0.0;
+    float  x = 0.0, y = 0.0;
+    int m, n;
+
+    // The first time, we build the fountain display list
+    if( !fountain_list )
+    {
+        // Start recording of a new display list
+        fountain_list = glGenLists( 1 );
+        glNewList( fountain_list, GL_COMPILE_AND_EXECUTE );
+
+        // Set fountain material
+        glMaterialfv( GL_FRONT, GL_DIFFUSE,   fountain_diffuse );
+        glMaterialfv( GL_FRONT, GL_SPECULAR,  fountain_specular );
+        glMaterialf(  GL_FRONT, GL_SHININESS, fountain_shininess );
+
+        // Build fountain using triangle strips
+        for( n = 0; n < FOUNTAIN_SIDE_POINTS-1; n ++ )
+        {
+            glBegin( GL_TRIANGLE_STRIP );
+            for( m = 0; m <= FOUNTAIN_SWEEP_STEPS; m ++ )
+            {
+                angle = cast(double) m * (2.0*PI/cast(double)FOUNTAIN_SWEEP_STEPS);
+                x = cast(float) cos( angle );
+                y = cast(float) sin( angle );
+
+                // Draw triangle strip
+                glNormal3f( x * fountain_normal[ n*2+2 ],
+                            y * fountain_normal[ n*2+2 ],
+                            fountain_normal[ n*2+3 ] );
+                glVertex3f( x * fountain_side[ n*2+2 ],
+                            y * fountain_side[ n*2+2 ],
+                            fountain_side[ n*2+3 ] );
+                glNormal3f( x * fountain_normal[ n*2 ],
+                            y * fountain_normal[ n*2 ],
+                            fountain_normal[ n*2+1 ] );
+                glVertex3f( x * fountain_side[ n*2 ],
+                            y * fountain_side[ n*2 ],
+                            fountain_side[ n*2+1 ] );
+            }
+            glEnd();
+        }
+
+        // End recording of display list
+        glEndList();
+    }
+    else
+    {
+        // Playback display list
+        glCallList( fountain_list );
+    }
+}
+
+
+//========================================================================
+// TesselateFloor() - Recursive function for building variable tesselated
+// floor
+//========================================================================
+
+void TesselateFloor( float x1, float y1, float x2, float y2,
+    int recursion )
+{
+    float delta, x, y;
+
+    // Last recursion?
+    if( recursion >= 5 )
+    {
+        delta = 999999.0f;
+    }
+    else
+    {
+        x = fabs(x1) < fabs(x2) ? fabs(x1) : fabs(x2);
+        y = fabs(y1) < fabs(y2) ? fabs(y1) : fabs(y2);
+        delta = x*x + y*y;
+    }
+
+    // Recurse further?
+    if( delta < 0.1f )
+    {
+        x = (x1+x2) * 0.5f;
+        y = (y1+y2) * 0.5f;
+        TesselateFloor( x1,y1,  x, y, recursion + 1 );
+        TesselateFloor(  x,y1, x2, y, recursion + 1 );
+        TesselateFloor( x1, y,  x,y2, recursion + 1 );
+        TesselateFloor(  x, y, x2,y2, recursion + 1 );
+    }
+    else
+    {
+        glTexCoord2f( x1*30.0f, y1*30.0f );
+        glVertex3f( x1*80.0f, y1*80.0f , 0.0f );
+        glTexCoord2f( x2*30.0f, y1*30.0f );
+        glVertex3f( x2*80.0f, y1*80.0f , 0.0f );
+        glTexCoord2f( x2*30.0f, y2*30.0f );
+        glVertex3f( x2*80.0f, y2*80.0f , 0.0f );
+        glTexCoord2f( x1*30.0f, y2*30.0f );
+        glVertex3f( x1*80.0f, y2*80.0f , 0.0f );
+    }
+}
+
+
+//========================================================================
+// DrawFloor() - Draw floor. We builde the floor recursively, and let the
+// tesselation in the centre (near x,y=0,0) be high, while the selleation
+// around the edges be low.
+//========================================================================
+
+void DrawFloor()
+{
+    static GLuint floor_list = 0;
+
+    // Select floor texture
+    if( !wireframe )
+    {
+        glEnable( GL_TEXTURE_2D );
+        glBindTexture( GL_TEXTURE_2D, floor_tex_id );
+    }
+
+    // The first time, we build the floor display list
+    if( !floor_list )
+    {
+        // Start recording of a new display list
+        floor_list = glGenLists( 1 );
+        glNewList( floor_list, GL_COMPILE_AND_EXECUTE );
+
+        // Set floor material
+        glMaterialfv( GL_FRONT, GL_DIFFUSE, floor_diffuse );
+        glMaterialfv( GL_FRONT, GL_SPECULAR, floor_specular );
+        glMaterialf(  GL_FRONT, GL_SHININESS, floor_shininess );
+
+        // Draw floor as a bunch of triangle strips (high tesselation
+        // improves lighting)
+        glNormal3f( 0.0f, 0.0f, 1.0f );
+        glBegin( GL_QUADS );
+        TesselateFloor( -1.0f,-1.0f, 0.0f,0.0f, 0 );
+        TesselateFloor(  0.0f,-1.0f, 1.0f,0.0f, 0 );
+        TesselateFloor(  0.0f, 0.0f, 1.0f,1.0f, 0 );
+        TesselateFloor( -1.0f, 0.0f, 0.0f,1.0f, 0 );
+        glEnd();
+
+        // End recording of display list
+        glEndList();
+    }
+    else
+    {
+        // Playback display list
+        glCallList( floor_list );
+    }
+
+    glDisable( GL_TEXTURE_2D );
+
+}
+
+
+//========================================================================
+// SetupLights() - Position and configure light sources
+//========================================================================
+
+void SetupLights()
+{
+    float[4] l1pos, l1amb, l1dif, l1spec;
+    float[4] l2pos, l2amb, l2dif, l2spec;
+
+    // Set light source 1 parameters
+    l1pos[0] = 0.0f; l1pos[1] = -9.0f; l1pos[2] = 8.0f; l1pos[3] = 1.0f;
+    l1amb[0] = 0.2f; l1amb[1] = 0.2f; l1amb[2] = 0.2f; l1amb[3] = 1.0f;
+    l1dif[0] = 0.8f; l1dif[1] = 0.4f; l1dif[2] = 0.2f; l1dif[3] = 1.0f;
+    l1spec[0] = 1.0f; l1spec[1] = 0.6f; l1spec[2] = 0.2f; l1spec[3] = 0.0f;
+
+    // Set light source 2 parameters
+    l2pos[0] = -15.0f; l2pos[1] = 12.0f; l2pos[2] = 1.5f; l2pos[3] = 1.0f;
+    l2amb[0] =   0.0f; l2amb[1] =  0.0f; l2amb[2] = 0.0f; l2amb[3] = 1.0f;
+    l2dif[0] =   0.2f; l2dif[1] =  0.4f; l2dif[2] = 0.8f; l2dif[3] = 1.0f;
+    l2spec[0] = 0.2f; l2spec[1] = 0.6f; l2spec[2] = 1.0f; l2spec[3] = 0.0f;
+
+    // Configure light sources in OpenGL
+    glLightfv( GL_LIGHT1, GL_POSITION, l1pos );
+    glLightfv( GL_LIGHT1, GL_AMBIENT, l1amb );
+    glLightfv( GL_LIGHT1, GL_DIFFUSE, l1dif );
+    glLightfv( GL_LIGHT1, GL_SPECULAR, l1spec );
+    glLightfv( GL_LIGHT2, GL_POSITION, l2pos );
+    glLightfv( GL_LIGHT2, GL_AMBIENT, l2amb );
+    glLightfv( GL_LIGHT2, GL_DIFFUSE, l2dif );
+    glLightfv( GL_LIGHT2, GL_SPECULAR, l2spec );
+    glLightfv( GL_LIGHT3, GL_POSITION, glow_pos );
+    glLightfv( GL_LIGHT3, GL_DIFFUSE, glow_color );
+    glLightfv( GL_LIGHT3, GL_SPECULAR, glow_color );
+
+    // Enable light sources
+    glEnable( GL_LIGHT1 );
+    glEnable( GL_LIGHT2 );
+    glEnable( GL_LIGHT3 );
+}
+
+
+//========================================================================
+// Draw() - Main rendering function
+//========================================================================
+
+void Draw( double t )
+{
+    double xpos, ypos, zpos, angle_x, angle_y, angle_z;
+    static double t_old = 0.0;
+    float  dt;
+
+    // Calculate frame-to-frame delta time
+    dt = cast(float)(t-t_old);
+    t_old = t;
+
+    // Setup viewport
+    glViewport( 0, 0, width, height );
+
+    // Clear color and Z-buffer
+    glClearColor( 0.1f, 0.1f, 0.1f, 1.0f );
+    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
+
+    // Setup projection
+    glMatrixMode( GL_PROJECTION );
+    glLoadIdentity();
+    gluPerspective( 65.0, cast(double)width/cast(double)height, 1.0, 60.0 );
+
+    // Setup camera
+    glMatrixMode( GL_MODELVIEW );
+    glLoadIdentity();
+
+    // Rotate camera
+    angle_x = 90.0 - 10.0;
+    angle_y = 10.0 * sin( 0.3 * t );
+    angle_z = 10.0 * t;
+    glRotated( -angle_x, 1.0, 0.0, 0.0 );
+    glRotated( -angle_y, 0.0, 1.0, 0.0 );
+    glRotated( -angle_z, 0.0, 0.0, 1.0 );
+
+    // Translate camera
+    xpos =  15.0 * sin( (PI/180.0) * angle_z ) +
+             2.0 * sin( (PI/180.0) * 3.1 * t );
+    ypos = -15.0 * cos( (PI/180.0) * angle_z ) +
+             2.0 * cos( (PI/180.0) * 2.9 * t );
+    zpos = 4.0 + 2.0 * cos( (PI/180.0) * 4.9 * t );
+    glTranslated( -xpos, -ypos, -zpos );
+
+    // Enable face culling
+    glFrontFace( GL_CCW );
+    glCullFace( GL_BACK );
+    glEnable( GL_CULL_FACE );
+
+    // Enable lighting
+    SetupLights();
+    glEnable( GL_LIGHTING );
+
+    // Enable fog (dim details far away)
+    glEnable( GL_FOG );
+    glFogi( GL_FOG_MODE, GL_EXP );
+    glFogf( GL_FOG_DENSITY, 0.05f );
+    glFogfv( GL_FOG_COLOR, fog_color );
+
+    // Draw floor
+    DrawFloor();
+
+    // Enable Z-buffering
+    glEnable( GL_DEPTH_TEST );
+    glDepthFunc( GL_LEQUAL );
+    glDepthMask( GL_TRUE );
+
+    // Draw fountain
+    DrawFountain();
+
+    // Disable fog & lighting
+    glDisable( GL_LIGHTING );
+    glDisable( GL_FOG );
+
+    // Draw all particles (must be drawn after all solid objects have been
+    // drawn!)
+    DrawParticles( t, dt );
+
+    // Z-buffer not needed anymore
+    glDisable( GL_DEPTH_TEST );
+}
+
+
+//========================================================================
+// Resize() - GLFW window resize callback function
+//========================================================================
+
+extern (Windows)
+{
+  void Resize( int x, int y )
+    {
+      width = x;
+      height = y > 0 ? y : 1;   // Prevent division by zero in aspect calc.
+    }
+}
+
+//========================================================================
+// Input callback functions
+//========================================================================
+
+extern (Windows)
+{
+  void KeyFun( int key, int action )
+    {
+      if( action == GLFW_PRESS )
+	{
+	  switch( key )
+	    {
+	    case GLFW_KEY_ESC:
+	      running = 0;
+	      break;
+	    case 'W':
+	      wireframe = !wireframe;
+	      glPolygonMode( GL_FRONT_AND_BACK,
+			     wireframe ? GL_LINE : GL_FILL );
+	      break;
+	    default:
+	      break;
+	    }
+	}
+    }
+}
+
+//========================================================================
+// PhysicsThreadFun() - Thread for updating particle physics
+//========================================================================
+
+extern (Windows)
+{
+  void PhysicsThreadFun( void *arg )
+    {
+      while( running )
+	{
+	  // Lock mutex
+	  glfwLockMutex( thread_sync.particles_lock );
+
+	  // Wait for particle drawing to be done
+	  while( running && thread_sync.p_frame > thread_sync.d_frame )
+	    {
+	      glfwWaitCond( thread_sync.d_done, thread_sync.particles_lock,
+			    0.1 );
+	    }
+
+	  // No longer running?
+	  if( !running )
+	    {
+	      break;
+	    }
+
+	  // Update particles
+	  ParticleEngine( thread_sync.t, thread_sync.dt );
+
+	  // Update frame counter
+	  thread_sync.p_frame ++;
+
+	  // Unlock mutex and signal drawing thread
+	  glfwUnlockMutex( thread_sync.particles_lock );
+	  glfwSignalCond( thread_sync.p_done );
+	}
+    }
+}
+
+//========================================================================
+// main()
+//========================================================================
+
+int main(char[][] args)
+{
+    int        i=0, frames=0, benchmark=0;
+    double     t0=0.0, t=0.0;
+    GLFWthread physics_thread = 0;
+
+    // Use multithreading by default, but don't benchmark
+    multithreading = 1;
+    benchmark = 0;
+
+    // Check command line arguments
+    for( i = 1; i < args.length; i ++ )
+    {
+        // Use benchmarking?
+        if( strcmp( args[i], "-b" ) == 0 )
+        {
+            benchmark = 1;
+        }
+
+        // Force multithreading off?
+        else if( strcmp( args[i], "-s" ) == 0 )
+        {
+            multithreading = 0;
+        }
+
+        // With a Finder launch on Mac OS X we get a bogus -psn_0_46268417
+        // kind of argument (actual numbers vary). Ignore it.
+        // else if( strncmp( args[i], "-psn_", 5) == 0 ) { }
+
+        // Usage
+        else
+        {
+            if( strcmp( args[i], "-?" ) != 0 )
+            {
+                printf( "Unknown option %.*s\n\n", args[ i ] );
+            }
+            printf( "Usage: %.*s [options]\n", args[ 0 ] );
+            printf( "\n");
+            printf( "Options:\n" );
+            printf( " -b   Benchmark (run program for 60 s)\n" );
+            printf( " -s   Run program as single thread (default is to use two threads)\n" );
+            printf( " -?   Display this text\n" );
+            printf( "\n");
+            printf( "Program runtime controls:\n" );
+            printf( " w    Toggle wireframe mode\n" );
+            printf( " ESC  Exit program\n" );
+	    return 0;
+        }
+    }
+
+    // Initialize GLFW
+    glfwInit();
+
+    // Open OpenGL fullscreen window
+    if( !glfwOpenWindow( WIDTH, HEIGHT, 5,6,5,0, 16,0, GLFW_FULLSCREEN ) )
+    {
+        glfwTerminate();
+	return 0;
+    }
+
+    // Set window title
+    glfwSetWindowTitle( "Particle engine" );
+
+    // Disable VSync (we want to get as high FPS as possible!)
+    glfwSwapInterval( 0 );
+
+    // Window resize callback function
+    glfwSetWindowSizeCallback( &Resize );
+
+    // Set keyboard input callback function
+    glfwSetKeyCallback( &KeyFun );
+
+    // Upload particle texture
+    glGenTextures( 1, &particle_tex_id );
+    glBindTexture( GL_TEXTURE_2D, particle_tex_id );
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_LUMINANCE, P_TEX_WIDTH, P_TEX_HEIGHT,
+                  0, GL_LUMINANCE, GL_UNSIGNED_BYTE, particle_texture );
+
+    // Upload floor texture
+    glGenTextures( 1, &floor_tex_id );
+    glBindTexture( GL_TEXTURE_2D, floor_tex_id );
+    glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
+    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
+    glTexImage2D( GL_TEXTURE_2D, 0, GL_LUMINANCE, F_TEX_WIDTH, F_TEX_HEIGHT,
+                  0, GL_LUMINANCE, GL_UNSIGNED_BYTE, floor_texture );
+
+    // Check if we have GL_EXT_separate_specular_color, and if so use it
+    // (This extension should ALWAYS be used when OpenGL lighting is used
+    // together with texturing, since it gives more realistic results)
+    if( glfwExtensionSupported( "GL_EXT_separate_specular_color" ) )
+    {
+        glLightModeli( GL_LIGHT_MODEL_COLOR_CONTROL_EXT,
+                       GL_SEPARATE_SPECULAR_COLOR_EXT );
+    }
+
+    // Set filled polygon mode as default (not wireframe)
+    glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
+    wireframe = 0;
+
+    // Clear particle system
+    for( i = 0; i < MAX_PARTICLES; i ++ )
+    {
+        particles[ i ].active = 0;
+    }
+    min_age = 0.0f;
+
+    // Set "running" flag
+    running = 1;
+
+    // Set initial times
+    thread_sync.t  = 0.0;
+    thread_sync.dt = 0.001f;
+
+    // Init threading
+    if( multithreading )
+    {
+        thread_sync.p_frame = 0;
+        thread_sync.d_frame = 0;
+        thread_sync.particles_lock = glfwCreateMutex();
+        thread_sync.p_done = glfwCreateCond();
+        thread_sync.d_done = glfwCreateCond();
+        physics_thread = glfwCreateThread( &PhysicsThreadFun, null );
+    }
+
+    // Main loop
+    t0 = glfwGetTime();
+    frames = 0;
+    while( running )
+    {
+        // Get frame time
+        t = glfwGetTime() - t0;
+
+        // Draw...
+        Draw( t );
+
+        // Swap buffers
+        glfwSwapBuffers();
+
+        // Check if window was closed
+        running = running && glfwGetWindowParam( GLFW_OPENED );
+
+        // Increase frame count
+        frames ++;
+
+        // End of benchmark?
+        if( benchmark && t >= 60.0 )
+        {
+            running = 0;
+        }
+    }
+    t = glfwGetTime() - t0;
+
+    // Wait for particle physics thread to die
+    if( multithreading )
+    {
+        glfwWaitThread( physics_thread, GLFW_WAIT );
+    }
+
+    // Display profiling information
+    printf( "%d frames in %.2f seconds = %.1f FPS", frames, t,
+            cast(double)frames / t );
+    printf( " (multithreading %.*s)\n", multithreading ? "on" : "off" );
+
+    // Terminate OpenGL
+    glfwTerminate();
+
+    return 0;
+}