ruby-opengl 0.60.1 → 0.61.0

data/examples/misc/font-glut.rb

@@ -1,46 +0,0 @@
-require 'opengl'
-include Gl,Glu,Glut
-
-display = Proc.new do
-	glClear(GL_COLOR_BUFFER_BIT)
-	GL.LoadIdentity
-	
-	glRasterPos2d(100,100)
-	"Hello Bitmap".each_byte { |x| glutBitmapCharacter(GLUT_BITMAP_9_BY_15, x) }
-	
-	GL.Translate(100, 250, 0)
-	GL.Scale(0.5, 0.5, 1)
-	"Hello Stroke".each_byte { |x| glutStrokeCharacter(GLUT_STROKE_ROMAN, x) }
-	
-	glutSwapBuffers()
-end
-
-reshape = Proc.new do |w, h|
-	glViewport(0, 0,  w,  h)
-	glMatrixMode(GL_PROJECTION)
-	glLoadIdentity()
-	glOrtho(0.0, w, 0.0, h, -1.0, 1.0)
-	glMatrixMode(GL_MODELVIEW)
-end
-
-keyboard = Proc.new do |key, x, y|
-	case (key)
-		when ?\e
-			exit(0)
-	end
-end
-
-#  Main Loop
-#  Open window with initial window size, title bar, 
-#  color index display mode, and handle input events.
-#
-glutInit
-glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB)
-glutInitWindowSize(500, 500)
-glutInitWindowPosition(100, 100)
-glutCreateWindow($0)
-
-glutReshapeFunc(reshape)
-glutDisplayFunc(display)
-glutKeyboardFunc(keyboard)
-glutMainLoop

data/examples/misc/glfwtest.rb

@@ -1,30 +0,0 @@
-require 'opengl'
-require 'glfw'
-
-#init
-Glfw.glfwOpenWindow( 500,500, 0,0,0,0, 32,0, Glfw::GLFW_WINDOW )
-
-# main loop
-while true
-	if( Glfw.glfwGetWindowParam( Glfw::GLFW_OPENED ) == false ||
-		  Glfw.glfwGetKey(Glfw::GLFW_KEY_ESC) == Glfw::GLFW_PRESS )
-		break
-	end
-
-	Gl.glClear( Gl::GL_COLOR_BUFFER_BIT | Gl::GL_DEPTH_BUFFER_BIT )
-
-	Gl.glBegin( Gl::GL_POLYGON )
-	Gl.glColor3f( 1.0, 0.0, 0.0 )
-	Gl.glVertex2f( -0.5, -0.5 )
-	Gl.glColor3f( 0.0, 1.0, 0.0 )
-	Gl.glVertex2f( -0.5,  0.5 )
-	Gl.glColor3f( 0.0, 0.0, 1.0 )
-	Gl.glVertex2f(  0.5,  0.5 )
-	Gl.glColor3f( 1.0, 0.0, 1.0 )
-	Gl.glVertex2f(  0.5, -0.5 )
-	Gl.glEnd
-
-  Glfw.glfwSwapBuffers()
-
-	sleep 0.01 # to avoid consuming all CPU power
-end

data/examples/misc/plane.rb

@@ -1,161 +0,0 @@
-#!/usr/bin/env ruby -rubygems
-#/* Copyright (c) Mark J. Kilgard, 1994. */
-#
-#/*
-# * (c) Copyright 1993, Silicon Graphics, Inc.
-# * ALL RIGHTS RESERVED 
-# * Permission to use, copy, modify, and distribute this software for 
-# * any purpose and without fee is hereby granted, provided that the above
-# * copyright notice appear in all copies and that both the copyright notice
-# * and this permission notice appear in supporting documentation, and that 
-# * the name of Silicon Graphics, Inc. not be used in advertising
-# * or publicity pertaining to distribution of the software without specific,
-# * written prior permission. 
-# *
-# * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
-# * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
-# * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
-# * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
-# * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
-# * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
-# * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
-# * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
-# * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
-# * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
-# * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
-# * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
-# * 
-# * US Government Users Restricted Rights 
-# * Use, duplication, or disclosure by the Government is subject to
-# * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
-# * (c)(1)(ii) of the Rights in Technical Data and Computer Software
-# * clause at DFARS 252.227-7013 and/or in similar or successor
-# * clauses in the FAR or the DOD or NASA FAR Supplement.
-# * Unpublished-- rights reserved under the copyright laws of the
-# * United States.  Contractor/manufacturer is Silicon Graphics,
-# * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
-# *
-# * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
-# */
-#/*
-# *  plane.c
-# *  This program demonstrates the use of local versus 
-# *  infinite lighting on a flat plane.
-# */
-
-require "gl"
-require "glut"
-require "mathn"
-
-# /*  Initialize material property, light source, and lighting model.
-# */
-def myinit
-    mat_ambient = [ 0.0, 0.0, 0.0, 1.0 ];
-#/*   mat_specular and mat_shininess are NOT default values	*/
-    mat_diffuse = [ 0.4, 0.4, 0.4, 1.0 ];
-    mat_specular = [ 1.0, 1.0, 1.0, 1.0 ];
-    mat_shininess = [ 15.0 ];
-
-    light_ambient = [ 0.0, 0.0, 0.0, 1.0 ];
-    light_diffuse = [ 1.0, 1.0, 1.0, 1.0 ];
-    light_specular = [ 1.0, 1.0, 1.0, 1.0 ];
-    lmodel_ambient = [ 0.2, 0.2, 0.2, 1.0 ];
-
-    Gl.glMaterial(Gl::GL_FRONT, Gl::GL_AMBIENT, mat_ambient);
-    Gl.glMaterial(Gl::GL_FRONT, Gl::GL_DIFFUSE, mat_diffuse);
-    Gl.glMaterial(Gl::GL_FRONT, Gl::GL_SPECULAR, mat_specular);
-    Gl.glMaterial(Gl::GL_FRONT, Gl::GL_SHININESS, *mat_shininess);
-    Gl.glLight(Gl::GL_LIGHT0, Gl::GL_AMBIENT, light_ambient);
-    Gl.glLight(Gl::GL_LIGHT0, Gl::GL_DIFFUSE, light_diffuse);
-    Gl.glLight(Gl::GL_LIGHT0, Gl::GL_SPECULAR, light_specular);
-    Gl.glLightModel(Gl::GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
-
-    Gl.glEnable(Gl::GL_LIGHTING);
-    Gl.glEnable(Gl::GL_LIGHT0);
-    Gl.glDepthFunc(Gl::GL_LESS);
-    Gl.glEnable(Gl::GL_DEPTH_TEST);
-end
-
-def drawPlane
-    Gl.glBegin(Gl::GL_QUADS);
-    Gl.glNormal(0.0, 0.0, 1.0);
-    Gl.glVertex(-1.0, -1.0, 0.0);
-    Gl.glVertex(0.0, -1.0, 0.0);
-    Gl.glVertex(0.0, 0.0, 0.0);
-    Gl.glVertex(-1.0, 0.0, 0.0);
-
-    Gl.glNormal(0.0, 0.0, 1.0);
-    Gl.glVertex(0.0, -1.0, 0.0);
-    Gl.glVertex(1.0, -1.0, 0.0);
-    Gl.glVertex(1.0, 0.0, 0.0);
-    Gl.glVertex(0.0, 0.0, 0.0);
-
-    Gl.glNormal(0.0, 0.0, 1.0);
-    Gl.glVertex(0.0, 0.0, 0.0);
-    Gl.glVertex(1.0, 0.0, 0.0);
-    Gl.glVertex(1.0, 1.0, 0.0);
-    Gl.glVertex(0.0, 1.0, 0.0);
-
-    Gl.glNormal(0.0, 0.0, 1.0);
-    Gl.glVertex(0.0, 0.0, 0.0);
-    Gl.glVertex(0.0, 1.0, 0.0);
-    Gl.glVertex(-1.0, 1.0, 0.0);
-    Gl.glVertex(-1.0, 0.0, 0.0);
-    Gl.glEnd();
-end
-
-display = Proc.new {
-    infinite_light = [ 1.0, 1.0, 1.0, 0.0 ];
-    local_light = [ 1.0, 1.0, 1.0, 1.0 ];
-
-    Gl.glClear(Gl::GL_COLOR_BUFFER_BIT | Gl::GL_DEPTH_BUFFER_BIT);
-
-    Gl.glPushMatrix();
-    Gl.glTranslate(-1.5, 0.0, 0.0);
-    Gl.glLight(Gl::GL_LIGHT0, Gl::GL_POSITION, infinite_light);
-    drawPlane();
-    Gl.glPopMatrix();
-
-    Gl.glPushMatrix();
-    Gl.glTranslate(1.5, 0.0, 0.0);
-    Gl.glLight(Gl::GL_LIGHT0, Gl::GL_POSITION, local_light);
-    drawPlane();
-    Gl.glPopMatrix();
-    Gl.glFlush();
-}
-
-myReshape = Proc.new {|w, h|
-    Gl.glViewport(0, 0, w, h);
-    Gl.glMatrixMode(Gl::GL_PROJECTION);
-    Gl.glLoadIdentity();
-    if (w <= h) 
-	Gl.glOrtho(-1.5, 1.5, -1.5*h/w, 1.5*h/w, -10.0, 10.0);
-    else 
-	Gl.glOrtho(-1.5*w/h, 1.5*w/h, -1.5, 1.5, -10.0, 10.0);
-    end
-    Gl.glMatrixMode(Gl::GL_MODELVIEW);
-}
-
-# Keyboard handler to exit when ESC is typed
-keyboard = lambda do |key, x, y|
-  case(key)
-  when ?\e
-    exit(0)
-  end
-end
-
-#/*  Main Loop
-# *  Open window with initial window size, title bar, 
-# *  RGBA display mode, and handle input events.
-# */
-#int main(int argc, char** argv)
-#{
-    Glut.glutInit
-    Glut.glutInitDisplayMode(Glut::GLUT_SINGLE | Glut::GLUT_RGB | Glut::GLUT_DEPTH);
-    Glut.glutInitWindowSize(500, 200);
-    Glut.glutCreateWindow($0);
-    myinit();
-    Glut.glutReshapeFunc(myReshape);
-    Glut.glutDisplayFunc(display);
-    Glut.glutKeyboardFunc(keyboard);
-    Glut.glutMainLoop();

data/examples/misc/readpixel.rb

@@ -1,65 +0,0 @@
-require 'opengl'
-include Gl,Glu,Glut
-
-begin
-	require "RMagick"
-rescue Exception
-	print "This sample needs RMagick Module.\n"
-	exit
-end
-
-WIDTH = 500
-HEIGHT = 500
-
-display = Proc.new do
-	glClear(GL_COLOR_BUFFER_BIT)
-	
-	glBegin(GL_LINES)
-	glVertex(0.5, 0.5)
-	glVertex(-0.5, -0.5)
-	glEnd
-	
-	glFlush()
-	
-	pixels = glReadPixels(0, 0, WIDTH, HEIGHT, GL_RGBA, GL_UNSIGNED_SHORT)
-	
-	image = Magick::Image.new(WIDTH, HEIGHT)
-	image.import_pixels(0, 0, WIDTH, HEIGHT, "RGBA", pixels,Magick::ShortPixel)
-	image.flip!
-	image.write("opengl_window.gif")
-end
-
-reshape = Proc.new do |w, h|
-	glViewport(0, 0,  w,  h)
-	glMatrixMode(GL_PROJECTION)
-	glLoadIdentity()
-	if (w <= h) 
-		gluOrtho2D(-1.0, 1.0, -h.to_f/w.to_f, h.to_f/w.to_f)
-	else 
-		gluOrtho2D(w.to_f/h.to_f, w.to_f/h.to_f, -1.0, 1.0)
-	end
-	glMatrixMode(GL_MODELVIEW)
-	glLoadIdentity()
-end
-
-
-keyboard = Proc.new do |key, x, y|
-	case (key)
-		when ?\e
-		exit(0);
-	end
-end
-
-#  Main Loop
-#  Open window with initial window size, title bar, 
-#  color index display mode, and handle input events.
-glutInit
-glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_ALPHA)
-glutInitWindowSize(WIDTH, HEIGHT)
-glutInitWindowPosition(100, 100)
-glutCreateWindow($0)
-glutReshapeFunc(reshape)
-glutDisplayFunc(display)
-glutKeyboardFunc(keyboard)
-glutMainLoop
-

data/examples/misc/sdltest.rb

@@ -1,34 +0,0 @@
-require 'opengl'
-require 'sdl'
-
-#init
-SDL.init(SDL::INIT_VIDEO)
-SDL.setGLAttr(SDL::GL_DOUBLEBUFFER,1)
-SDL.setVideoMode(512,512,32,SDL::OPENGL)
-
-# main loop
-while true
-	while event = SDL::Event2.poll
-		case event
-		when SDL::Event2::KeyDown, SDL::Event2::Quit
-			exit
-		end
-	end
-
-	Gl.glClear( Gl::GL_COLOR_BUFFER_BIT | Gl::GL_DEPTH_BUFFER_BIT )
-
-	Gl.glBegin( Gl::GL_POLYGON )
-	Gl.glColor3f( 1.0, 0.0, 0.0 )
-	Gl.glVertex2f( -0.5, -0.5 )
-	Gl.glColor3f( 0.0, 1.0, 0.0 )
-	Gl.glVertex2f( -0.5,  0.5 )
-	Gl.glColor3f( 0.0, 0.0, 1.0 )
-	Gl.glVertex2f(  0.5,  0.5 )
-	Gl.glColor3f( 1.0, 0.0, 1.0 )
-	Gl.glVertex2f(  0.5, -0.5 )
-	Gl.glEnd
-
-	SDL.GLSwapBuffers()
-
-	sleep 0.01 # to avoid consuming all CPU power
-end

data/examples/misc/trislam.rb

@@ -1,828 +0,0 @@
-#!/usr/bin/env ruby
-
-# Purpose: Determine performance curves for various methods of pushing
-#          triangles and quads through the OpenGL pipeline
-
-# Copyright (c) 2004-2006, Geoff Broadwell; this script is released
-# as open source and may be distributed and modified under the terms
-# of either the Artistic License or the GNU General Public License,
-# in the same manner as Perl itself.  These licenses should have been
-# distributed to you as part of your Perl distribution, and can be
-# read using `perldoc perlartistic` and `perldoc perlgpl` respectively.
-
-# Conversion to ruby by Jan Dvorak <jan.dvorak@kraxnet.cz>
-
-require 'opengl'
-include Gl,Glu,Glut
-
-require 'mathn'
-
-require 'OGLBench'
-
-$VERSION = '0.1.24-ruby-p1'
-
-$test = 0
-$run = 0
-$done = false
-$ready = false
-
-### USER CONFIG
-
-# Primitive sizes (and therefore counts) are integer divisors of
-# (A^i * B^j * C^k ...) where good A, B, C, ... are relatively prime;
-# this number is used for the draw area height and width and defaults to:
-#     2^4 * 3^2 * 5 = 720
-# You may also want to get fewer data points across the same range by
-# directly using higher powers; for example:
-#     16  * 9   * 5 = 720
-#
-# my @max_powers = (16 => 1, 9 => 1, 5 => 1);
-$max_powers = { 2 => 4, 3 => 2, 5 => 1 }.to_a.flatten
-
-# Maximum quads along each axis for known slow versus usually fast tests;
-# chosen to be somewhat reasonable for most common settings of @max_powers
-# my $max_count_slow = 60;
-$max_count_slow = 154
-$max_count_fast = 154
-
-# Font to use to label graphs
-$font_style = GLUT_BITMAP_HELVETICA_10
-
-### MISC GLOBALS
-
-$conf = $app = $gl_info = nil
-$MIN_FRAMES = $MIN_SECONDS = 0
-$w = $h = 0
-$dls = {}
-$vas = {}
-$combos = $slow = $fast = 0
-$showing_graph = false
-$empty_time = $empty_frames = $total = 0
-$max = []
-$stats = []
-$stats_fixed = []
-
-### CODE
-
-def main
-	init()
-	print "Benchmarks:"
-
-	glutDisplayFunc(method(:cbDraw).to_proc)
-	glutIdleFunc(method(:cbDraw).to_proc)
-	glutKeyboardFunc(method(:cbKeyPressed).to_proc)
-	glutMainLoop()
-end
-
-def init
-	$stdout.sync = true
-
-	$combos = recurse_combos($max_powers)
-	$combos.sort!
-	$slow = $combos.select { |a| a <= $max_count_slow }
-	$fast = $combos.select { |a| a > $max_count_slow &&
-	                             a <= $max_count_slow }
-
-	# Choose drawing area size to match counts
-	$h = $w = $combos.last
-
-  default_conf = {
-			:title    => 'Triangle Slammer OpenGL Benchmark',
-			:geometry => "#{$w}x#{$h}",
-			:frames   => 10,
-			:seconds  => 1,
-	}
-  $conf, $app, $gl_info = OGLBench.basic_init(default_conf)
-
-
-	# Reduce indirections in inner loops
-	$MIN_FRAMES, $MIN_SECONDS = $conf[:frames], $conf[:seconds]
-	
-	# Let user know what's going on
-	show_user_message()
-
-	# Change projection to integer-pixel ortho
-	glMatrixMode(GL_PROJECTION)
-	glOrtho(0, $w, 0, $h, -1, 1)
-	glMatrixMode(GL_MODELVIEW)
-
-	# Make sure GL state is consistent for VA and DL creation
-	start_frame()
-	
-	# Create vertex arrays and display lists outside timing loop
-	init_vertex_arrays()
-	init_display_lists()
-	
-	# Clean up GL state
-	end_frame()
-end
-
-def recurse_combos(powers)
-	base, max_power, *rest = powers
-
-	return [1] if powers.size<1
-
-	combos = []	
-	(0..max_power).each do |power|
-		multiplier = base ** power
-		recurse_combos(rest).each do |item|
-			combos << (item*multiplier)
-		end
-	end
-	combos
-end
-
-def show_user_message
-	print <<"EOM";
-TRISLAM benchmarks several methods of pushing OpenGL primitives,
-testing each method with various primitive counts and sizes.
-During the benchmark, the test window will start out black, slowly
-brightening to white as testing progresses.  Once benchmarking is
-complete, the collected data will be dumped in tabular form.
-
-The configuration for this series of tests will be as follows:
-
-EOM
-
-	OGLBench.show_basic_config($conf, $gl_info, $VERSION)
-	
-	puts "standard runs:    #{$slow.join(' ')}"
-	puts "extra fast runs:  #{$fast.join(' ')}"
-	puts '-' * 79
-end
-
-
-def init_vertex_arrays
-	print "Init vertex arrays:"
-
-	$va_types.keys.sort.each do |type|
-		print " #{type}"
-		($slow + $fast).each do |count|
-			data = $va_types[type].call(count, $w / count.to_f)
-			va = data.pack("f*")
-			$vas["#{type}_#{count}"] = va
-		end
-	end	
-
-	print ".\n";
-end
-
-def init_display_lists
-	print "Init display lists:"
-
-	num_lists = $dl_types.size * ($slow + $fast).size
-	current = glGenLists(num_lists)
-
-	$dl_types.keys.sort.each do |type|
-		print " #{type}"
-		($slow + $fast).each do |count|
-			$dls["#{type}_#{count}"] = current
-			glNewList(current, GL_COMPILE)
-			$dl_types[type].call(count, $w / count.to_f)
-			glEndList()
-			current += 1
-		end
-	end    
-	puts "."
-end
-
-def benchmark
-	if ($test >= $tests.size)
-		print ".\n" if (!$done)
-		$done = true
-		return
-	end
-	name,draw,stats,class_ = $tests[$test]
-
-	counts = class_ == 'single' ? [1] : (class_ == 'slow' ? $slow : $slow + $fast)
-
-	if ($run == 0)
-		print " #{name}";
-
-		# After printing current test name, busy wait for a second
-		# so that the terminal can catch up and not do work while
-		# the GL timing is in progress
-		a = Time.now
-		while 1 > (Time.now - a) do end
-	end
-
-	count = counts[$run]
-  size  = $w / count
-
-	OGLBench.fade_to_white(($test + ($run.to_f / counts.size)) / $tests.size)
-
-	run_done = 0
-  frames   = 0
-  start    = Time.now
-
-  while (run_done==0)
-		start_frame()
-    draw.call(count, size.to_f)
-    end_frame()
-   
-    frames += 1
-    run_done = 1 if ($MIN_FRAMES <= frames &&
-             $MIN_SECONDS <= Time.now - start)
-	end
-	glFinish()
-  end_ = Time.now
-  time = end_ - start
-    
-	$stats << [name,count,time,frames] + stats.call(count,size.to_f)
-
-	$run += 1
-	if ($run >= counts.size)
-		$test += 1
-		$run = 0
-	end
-end
-
-def cleanup
-	fixup_stats()
-	show_stats()
-	draw_stats()
-end
-
-def start_frame
-	glClear(GL_COLOR_BUFFER_BIT |
-	        GL_DEPTH_BUFFER_BIT)
-end
-
-def end_frame
-	glFinish()
-end
-
-def fixup_stats
-	empty = $stats.shift
-    
-	$empty_time   = empty[2]
-  $empty_frames = empty[3]
-  empty_tpf = $empty_time.to_f / $empty_frames
-
-	$total = ['totl,','avg'] + [0] * 12
-	$max = ['max','max'] + [0] * 12
-
-	$stats.each do |stat|
-		name, count, time, frames, pixpf, prmpf, tpf, vpf = stat
-
-		# Subtract out empty loop time, and loop if negative result
-		# $time -= $empty_tpf * $frames;
-		if (time <= 0)
-			stat += [0] * 5
-			next
-		end
-    
-		# Calc "work", the geometric mean of pixels and vertices
-		workpf = Math::sqrt(pixpf * vpf)
-    
-		# Calc fps
-		fps = frames / time
-    
-		# Calc other perf stats
-		pixps = pixpf  * fps
-		prmps = prmpf  * fps
-		tps   = tpf    * fps
-		vps   = vpf    * fps
-		wps   = workpf * fps  
-		
-		# Add them to stat row
-		stat += [fps, pixps, prmps, tps, vps, wps]
-    
-		# Convert per frame counts to totals
-		(4..7).each { |i| stat[i] *= frames }
-
-		# Update running totals
-		(2..7).each { |i| $total[i] += stat[i] }
-			
-		# Update running maximums
-		(2..13).each do |i|
-			$max[i] = stat[i] if $max[i] < stat[i]
-		end
-	
-		$stats_fixed << stat
-	end
-
-	# Calc averages for totals line
-	(8..13).each { |i| $total[i] = $total[i-5] / $total[2].to_f }
-
-	$ready = true
-	$stats = $stats_fixed
-end
-
-
-def show_stats
-	basic = ["Name","Cnt","Time"]
-	raw =   ["Frms","Mpix","Kprim","Ktri","Kvert"]
-	calc = raw
-	scale = [ 0,   6,    3,    3,   3,    ] * 2
-	header = basic + raw + calc
-	scale.map! {|n| 10 ** n }
-	
-	g_form = "%9s%-*s %s\n"
-	h_form = '%-5s%3s %6s'   + ' %5s' * raw.size + ' ' + ' %5s' * calc.size + "\n"
-	format = '%-5s%3s %6.3f' + ' %5d' * raw.size + ' ' + ' %5d' * calc.size + "\n"
-
-	printf(g_form, '', 6 * 5 + 8, 'MEASURED', 'PER SECOND')
-  printf(h_form, *header)
-  printf(format, "empty", 1, $empty_time, $empty_frames, *([0] * 9))
-    #
-
-	($stats + [$total]).each do |stat|
-		st = stat.clone()
-		(0..scale.size-1).each do |i|
-			st[i + 3] /= scale[i]
-		end
-		printf(format,*st)
-	end
-end
-
-
-def make_quads_va(count,size)
-	data = []
-	(0 .. count-1).each do |y|
-		(0 .. count-1).each do |x|
-			data << x * size        << y * size + size
-			data << x * size        << y * size
-			data << x * size + size << y * size
-			data << x * size + size << y * size + size
-		end
-	end
-	data
-end
-
-def make_tris_va(count,size)
-	data = []
-	(0 .. count-1).each do |y|
-		(0 .. count-1).each do |x|
-			data << x * size        <<  y * size + size
-			data << x * size        <<  y * size
-			data << x * size + size <<  y * size + size
-	
-			data << x * size + size <<  y * size + size
-			data << x * size        <<  y * size
-			data << x * size + size <<  y * size
-		end
-	end
-	data
-end
-
-def make_qs_va(count,size)
-	data = []
-	(0 .. count-1).each do |y|
-		(0 .. count).each do |x|
-			data << x * size << y * size + size
-			data << x * size << y * size
-    end
-	end
-	data
-end
-
-def make_ts_va(count,size)
-	data = []
-	(0 .. count-1).each do |y|
-		(0 .. count).each do |x|
-			data << x * size << y * size + size
-			data << x * size << y * size
-    end
-	end
-	data
-end
-
-def draw_qs(count,size)
-	(0 .. count-1).each do |y|
-		glBegin(GL_QUAD_STRIP)
-		(0 .. count).each do |x|
-			glVertex2f(x * size, y * size + size)
-			glVertex2f(x * size, y * size )
-		end
-		glEnd()
-	end
-end
-
-def draw_ts(count,size)
-	(0 .. count-1).each do |y|
-		glBegin(GL_TRIANGLE_STRIP)
-		(0 .. count).each do |x|
-			glVertex2f(x * size, y * size + size)
-			glVertex2f(x * size, y * size )
-		end
-		glEnd()
-	end
-end
-
-def draw_qs_va(count,size)
-	va  = $vas["qs_#{count}"]
-	row = 2 * (count + 1)
-
-	glEnableClientState(GL_VERTEX_ARRAY)
-	glVertexPointer(2, GL_FLOAT, 0, va)
-	(0 .. count-1).each do |y|
-		glDrawArrays(GL_QUAD_STRIP, y * row, row)
-	end
-	glDisableClientState(GL_VERTEX_ARRAY)
-end
-
-def draw_ts_va(count,size)
-	va  = $vas["ts_#{count}"]
-	row = 2 * (count + 1)
-
-	glEnableClientState(GL_VERTEX_ARRAY)
-	glVertexPointer(2, GL_FLOAT, 0, va)
-	(0 .. count-1).each do |y|
-		glDrawArrays(GL_TRIANGLE_STRIP, y * row, row)
-	end
-	glDisableClientState(GL_VERTEX_ARRAY)
-end
-
-def draw_tris(count,size)
-	glBegin(GL_TRIANGLES)
-	(0 .. count-1).each do |y|
-		(0 .. count-1).each do |x|
-			glVertex2f(x * size       , y * size + size)
-			glVertex2f(x * size       , y * size       )
-			glVertex2f(x * size + size, y * size + size)
-	
-			glVertex2f(x * size + size, y * size + size)
-			glVertex2f(x * size       , y * size       )
-			glVertex2f(x * size + size, y * size       )
-		end
-	end
-	glEnd
-end
-
-def stats_tris(count,size)
-	length = size * count
-	area   = length * length
-	prims  = 2 * count * count
-	tris   =     prims
-	verts  = 3 * prims
-	
-	[area, prims, tris, verts]
-end
-
-def draw_empty(count,size)
-end
-
-def stats_empty(count,size)
-   [0,0,0,0]
-end
-
-def draw_quads(count,size)
-	glBegin(GL_QUADS)
-	(0 .. count-1).each do |y|
-		(0 .. count-1).each do |x|
-			glVertex2f(x * size       , y * size + size)
-			glVertex2f(x * size       , y * size       )
-			glVertex2f(x * size + size, y * size       )
-			glVertex2f(x * size + size, y * size + size)
-		end
-	end
-	glEnd
-end
-
-def stats_quads(count,size)
-	length = size * count
-	area   = length * length
-	prims  = count * count
-	tris   = 2 * prims
-	verts  = 4 * prims
-
-	[area, prims, tris, verts]
-end
-
-def stats_ts(count,size)
-	length = size * count
-	area   = length * length
-	prims  = count
-	tris   = 2 *  count      * prims
-	verts  = 2 * (count + 1) * prims
-	
-	[area, prims, tris, verts]
-end
-
-def stats_qs(count,size)
-	length = size * count
-	area   = length * length
-	prims  = count
-	tris   = 2 *  count      * prims
-	verts  = 2 * (count + 1) * prims
-	
-	[area, prims, tris, verts]
-end
-
-def draw_ts_dl(count,size)
-	glCallList($dls["ts_#{count}"]);
-end
-
-def draw_qs_dl(count,size)
-  glCallList($dls["qs_#{count}"]);
-end
-
-def draw_tris_va(count,size)
-	va = $vas["t_#{count}"]
-	
-	glVertexPointer(2, GL_FLOAT, 0, va)
-	
-	glEnableClientState(GL_VERTEX_ARRAY)
-	glDrawArrays(GL_TRIANGLES, 0, 6 * count * count)
-	glDisableClientState(GL_VERTEX_ARRAY)
-end
-
-def draw_quads_va(count,size)
-	va = $vas["q_#{count}"]
-	
-	glVertexPointer(2, GL_FLOAT, 0, va)
-	
-	glEnableClientState(GL_VERTEX_ARRAY)
-	glDrawArrays(GL_QUADS, 0, 4 * count * count)
-	glDisableClientState(GL_VERTEX_ARRAY)
-end
-
-
-def draw_ts_va_dl(count,size)
-	va = $vas["ts_#{count}"]
-	
-	glVertexPointer(2, GL_FLOAT, 0, va)
-	
-	glEnableClientState(GL_VERTEX_ARRAY)
-	glCallList($dls["tsv_#{count}"])
-	glDisableClientState(GL_VERTEX_ARRAY)
-end
-
-def draw_qs_va_dl(count,size)
-	va = $vas["qs_#{count}"]
-	
-	glVertexPointer(2, GL_FLOAT, 0, va)
-	
-	glEnableClientState(GL_VERTEX_ARRAY)
-	glCallList($dls["qsv_#{count}"])
-	glDisableClientState(GL_VERTEX_ARRAY)
-end
-
-
-def draw_stats
-	return if (!$ready)
-
-	# Graph config
-	x_off     = 10
-	y_off     = 10
-	tick_size = 3
-	val_space = 50
-	key_size  = 20
-	x_scale   = ($w - 4 * x_off) / (2 * ($fast.last || $slow.last))
-	key_scale = ($h - 4 * y_off) / (2 * $tests.size)
-
-	# Get a fresh black frame for graphing
-	glClearColor(0, 0, 0, 1)
-	start_frame()
-
-	# Use antialiased lines
-	glEnable(GL_BLEND)
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)
-	glEnable(GL_LINE_SMOOTH)
-	glHint(GL_LINE_SMOOTH_HINT, GL_NICEST)
-
-	# Draw axis ticks
-	glColor3f(1, 1, 1);
-	glBegin(GL_LINES);
-
-	([0] + $slow + $fast).each do |count|
-		x_tick = count * x_scale + x_off
-		glVertex2f(x_tick, y_off)
-		glVertex2f(x_tick, y_off - tick_size)
-		glVertex2f(x_tick, y_off + $h / 2)
-		glVertex2f(x_tick, y_off + $h / 2 - tick_size)
-		glVertex2f(x_tick + $w / 2, y_off + $h / 2)
-		glVertex2f(x_tick + $w / 2, y_off + $h / 2 - tick_size)
-	end
-	glEnd
-
-	x_tick = x_off + 3
-	val_max = (($h / 2 - 2 * y_off) / val_space).to_i
-
-	# Work
-	(0..val_max).each do |value|
-		y_tick = value * val_space + y_off
-
-		glBegin(GL_LINES)
-			glVertex2f(x_off,             y_tick)
-			glVertex2f(x_off - tick_size, y_tick)
-		glEnd
-	end
-
-	# Pixels
-	value = 0
-	val_max = $max[9] / mag_scale($max[9])
-	y_scale = ($h - 4 * y_off) / (2 * val_max)
-	val_inc = tick_inc(val_max,5)
-
-	while (value < val_max)
-		y_tick = (value * y_scale)  + y_off
-
-		glBegin(GL_LINES)
-		glVertex2f(x_off,              y_tick + $h / 2)
-		glVertex2f(x_off - tick_size, y_tick + $h / 2)
-		glEnd
-		OGLBench.draw_string($font_style, value.to_s, x_tick, y_tick + $h / 2) if (value!=0)
-		value += val_inc
-	end
-
-	# Vertices
-	value = 0
-	val_max = $max[12] / mag_scale($max[12])
-	y_scale = ($h - 4 * y_off) / (2 * val_max)
-	val_inc = tick_inc(val_max,5)
-	while (value < val_max)
-		y_tick = (value * y_scale)  + y_off
-
-		glBegin(GL_LINES)
-		glVertex2f(x_off + $w / 2,              y_tick + $h / 2)
-		glVertex2f(x_off + $w / 2 - tick_size,  y_tick + $h / 2)
-		glEnd
-
-		OGLBench.draw_string($font_style, value.to_s, x_tick + $w / 2, y_tick + $h / 2) if (value!=0)
-		value += val_inc
-	end
-
-	# Draw axes
-	glBegin(GL_LINE_STRIP)
-	glVertex2f(x_off,          $h / 2 - y_off)
-	glVertex2f(x_off,          y_off)
-	glVertex2f($w / 2 - x_off, y_off)
-	glEnd
-	glBegin(GL_LINE_STRIP)
-	glVertex2f(x_off,          $h - y_off)
-	glVertex2f(x_off,          $h / 2 + y_off)
-	glVertex2f($w / 2 - x_off, $h / 2 + y_off)
-	glEnd
-	glBegin(GL_LINE_STRIP)
-	glVertex2f($w / 2 + x_off, $h - y_off)
-	glVertex2f($w / 2 + x_off, $h / 2 + y_off)
-	glVertex2f($w - x_off,     $h / 2 + y_off)
-	glEnd
-
-  # Draw color key
-	(0..$tests.size - 1).each do |num|
-		test = $tests[num]
-		name,color,stipple = [test[0]] + test[-2,2]
-		glEnable(GL_LINE_STIPPLE)
-		glLineStipple(3, stipple)
-
-		glBegin(GL_LINES)
-		glColor3fv(color)
-		glVertex2f(x_off + $w / 2,            y_off + num * key_scale)
-		glVertex2f(x_off + $w / 2 + key_size, y_off + num * key_scale)
-		glEnd()
-
-		glDisable(GL_LINE_STIPPLE)
-
-		OGLBench.draw_string($font_style, name, x_off + $w / 2 + key_size * 2,  y_off + num * key_scale)
-	end
-
-	# Draw performance graph lines
-
-	# Pixels per second
-	draw_one_stat(x_off, y_off + $h / 2, y_off, x_scale, 9)
-	glColor3f(1, 1, 1)
-
-	OGLBench.draw_string($font_style, mag_char($max[9]) + " Pixels/Sec", $w / 4, $h - 2 * y_off)
-
-	# Vertices per second
-	draw_one_stat(x_off + $w / 2, y_off + $h / 2, y_off, x_scale, 12)
-	glColor3f(1, 1, 1)
-	OGLBench.draw_string($font_style, mag_char($max[12]) + " Vertices/Sec", 3 * $w / 4, $h - 2 * y_off)
-
-	# "Work" per second, the geometric mean of pixels and vertices
-	draw_one_stat(x_off, y_off, y_off, x_scale, 13)
-	glColor3f(1, 1, 1)
-
-	OGLBench.draw_string($font_style, "Work/Sec", $w / 4, $h / 2 - 2 * y_off)
-
-	# Show our graph
-	end_frame();
-	$showing_graph = true
-end
-
-def draw_one_stat(x_loc,y_loc,y_off,x_scale,num)
-	max     = $max[num]
-	y_scale = ($h - 4 * y_off) / (2 * max)
-	colors = {}
-	$tests.each do |test| colors[test[0]] = test[-2] end
-
-	stipple = {}
-	$tests.each do |test| stipple[test[0]] = test[-1] end
-
-	last = ''
-	
-	glEnable(GL_LINE_STIPPLE)
-	glBegin(GL_LINE_STRIP)
-	$stats.each_with_index do |stat,run|
-		name,count, st = stat[0,2] + [stat[num]]
-
-		if name != last
-			glEnd
-			glLineStipple(3, stipple[name])
-			glBegin(GL_LINE_STRIP)
-			last = name
-		end
-
-		glColor3fv(colors[name])
-		glVertex2f(count * x_scale + x_loc, st * y_scale + y_loc)
-	end
-	glEnd
-	glDisable(GL_LINE_STIPPLE)
-end
-
-
-def kilo_mag(num)
-	mag = (Math::log(num) / Math::log(10)).to_i
-	(mag / 3)
-end
-
-def mag_char(num)
-	['','K','M','G','T','P','E','Z','Y'][kilo_mag(num)]
-end
-
-def mag_scale(num)
-	10 ** (3*kilo_mag(num))
-end
-
-def tick_inc(max,parts = 5)
-	return (max / parts.to_f) if (max < 1)
-
-	mag = (Math::log(max) / Math::log(10)).to_i
-	scl = (10 ** (mag - 1))
-	inc = max / (scl * parts)
-	
-	if (inc > 7.5)
-		inc = 10
-	elsif (inc > 3.5)
-		inc = 5
-	elsif (inc > 1.5)
-		inc = 2
-	else
-		inc = 1
-	end	
-	(inc * scl.to_f)
-end
-
-# State engine
-def cbDraw
-	if (!$done)
-		benchmark()
-	elsif (!$ready)
-		cleanup()
-	else
-		sleep(1)
-		draw_stats()
-	end
-end
-
-# Keyboard handler
-def cbKeyPressed(key,x,y)
-  if (key == ?\e or key == ?q)
-		glutDestroyWindow($app)
-		exit(0)
-	end
-	if ($done && key == ?r)
-		draw_stats()
-	end
-end
-
-
-### METHODS TO BENCHMARK
-
-$va_types = {
-	"q"   => method(:make_quads_va),
-	"t"   => method(:make_tris_va),
-	"qs"  => method(:make_qs_va),
-	"ts"  => method(:make_ts_va),
-}
-
-$dl_types = {
-	"qs"  => method(:draw_qs),
-  "ts"  => method(:draw_ts),
-  "qsv" => method(:draw_qs_va),
-	"tsv" => method(:draw_ts_va),
-}
-
-$tests = [
-	# Nick    Draw Routine          Stats Calc           Type     Graph Color
-#	["empty",method(:draw_empty),   method(:stats_empty),'single',[1 ,  1,  1], 0xFFFF],
-	["t"    ,method(:draw_tris),    method(:stats_tris) ,'slow',  [1 ,  0,  0], 0xAAAA],
-	["q"    ,method(:draw_quads),   method(:stats_quads),'slow',  [1 ,0.5,  0], 0xAAAA],
-	["ts"   ,method(:draw_ts),      method(:stats_ts),   'slow',  [1 ,  1,  0], 0xAAAA],
-	["qs"   ,method(:draw_qs),      method(:stats_qs),   'slow',  [0 ,  1,  0], 0xAAAA],
-	["tsd"  ,method(:draw_ts_dl),   method(:stats_ts),   'fast',  [0 ,  1,  1], 0xAAAA],
-	["qsd"  ,method(:draw_qs_dl),   method(:stats_qs),   'fast',  [0 ,  0,  1], 0xAAAA],
-	["tv"   ,method(:draw_tris_va), method(:stats_tris), 'fast',  [0.8,  0, 0], 0xFFFF],
-	["qv"   ,method(:draw_quads_va),method(:stats_quads),'fast',  [0.8,0.4, 0], 0xFFFF],
-	["tsv"  ,method(:draw_ts_va),   method(:stats_ts),   'fast',  [0.8,0.8, 0], 0xFFFF],
-	["qsv"  ,method(:draw_qs_va),   method(:stats_qs),   'fast',  [0 ,0.8,  0], 0xFFFF],
-	["tsvd" ,method(:draw_ts_va_dl),method(:stats_ts),   'fast',  [0 ,0.8,0.8], 0xFFFF],
-	["qsvd" ,method(:draw_qs_va_dl),method(:stats_qs),   'fast',  [0 ,  0,0.8], 0xFFFF],
-]
-
-# Start from main function ()
-main()
-