ruby-opengl 0.60.0-i386-mswin32

data/examples/NeHe/nehe_lesson36.rb

@@ -0,0 +1,303 @@
+# Nehe Lesson 36 Code
+# modified from immediate mode to use vertex arrays for helix drawing
+require 'opengl'
+include Gl,Glu,Glut
+include Math
+
+def emptyTexture
+	# Create Storage Space For Texture Data (128x128x4)
+	data = ([0]*4*128*128).pack("f*")
+	txtnumber = glGenTextures(1) # Create 1 Texture
+	glBindTexture(GL_TEXTURE_2D, txtnumber[0]) # Bind The Texture 
+	glTexImage2D(GL_TEXTURE_2D, 0, 4, 128, 128, 0,
+		GL_RGBA, GL_FLOAT, data) # Build Texture Using Information In data
+	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR)
+	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR)
+	return txtnumber[0] # Return The Texture ID
+end
+
+def init
+	global_ambient = [0.2, 0.2, 0.2, 1.0] # Set Ambient Lighting To Fairly Dark Light (No Color)
+	light0pos = [0.0, 5.0, 10.0, 1.0] # Set The Light Position
+	light0ambient = [0.2, 0.2, 0.2, 1.0] # More Ambient Light
+	light0diffuse = [0.3, 0.3, 0.3, 1.0] # Set The Diffuse Light A Bit Brighter
+	light0specular = [0.8, 0.8, 0.8, 1.0] # Fairly Bright Specular Lighting
+
+	lmodel_ambient = [0.2,0.2,0.2,1.0] # And More Ambient Light
+
+	$angle = 0.0 # Set Starting Angle To Zero 
+	
+	$lasttime = 0
+	
+	$blurTexture = emptyTexture() # Create Our Empty Texture
+
+	$helix_v,$helix_n = createHelix()
+	glVertexPointer(3,GL_FLOAT,0,$helix_v.flatten.pack("f*"))
+	glNormalPointer(GL_FLOAT,0,$helix_n.flatten.pack("f*"))
+
+	glLoadIdentity() # Reset The Modelview Matrix
+
+	glEnable(GL_DEPTH_TEST) # Enable Depth Testing
+
+	glLightModelfv(GL_LIGHT_MODEL_AMBIENT,lmodel_ambient) # Set The Ambient Light Model
+	
+	glLightModelfv(GL_LIGHT_MODEL_AMBIENT,global_ambient) # Set The Global Ambient Light Model
+	glLightfv(GL_LIGHT0, GL_POSITION, light0pos) # Set The Lights Position
+	glLightfv(GL_LIGHT0, GL_AMBIENT, light0ambient)	# Set The Ambient Light
+	glLightfv(GL_LIGHT0, GL_DIFFUSE, light0diffuse) # Set The Diffuse Light
+	glLightfv(GL_LIGHT0, GL_SPECULAR, light0specular)	# Set Up Specular Lighting
+	glEnable(GL_LIGHTING) # Enable Lighting
+	glEnable(GL_LIGHT0) # Enable Light0
+
+	glShadeModel(GL_SMOOTH) # Select Smooth Shading
+
+	glMateriali(GL_FRONT, GL_SHININESS, 128)
+	glClearColor(0.0, 0.0, 0.0, 0.5) # Set The Clear Color To Black
+end
+
+# Keyboard handler to exit when ESC is typed
+keyboard = lambda do |key, x, y|
+	case(key)
+		when ?\e
+			exit(0)
+	end
+	glutPostRedisplay
+end
+
+reshape = lambda do |w,h|
+	glMatrixMode(GL_PROJECTION)
+	glViewport(0,0,w,h)
+	glLoadIdentity()
+	width = 0.5
+	height = 0.5 * h/w;
+	glFrustum(-width,width,-height,height,1.0,2000.0)
+	glMatrixMode(GL_MODELVIEW)
+	glViewport(0,0,w,h)
+end
+
+def viewOrtho
+	glMatrixMode(GL_PROJECTION) # Select Projection
+	glPushMatrix() # Push The Matrix
+	glLoadIdentity() # Reset The Matrix
+	width = glutGet(GLUT_WINDOW_WIDTH)
+	height = glutGet(GLUT_WINDOW_HEIGHT)
+	glOrtho( 0, width , height , 0, -1, 1 ) # Select Ortho Mode (widthxheight)
+	glMatrixMode(GL_MODELVIEW) # Select Modelview Matrix
+	glPushMatrix() # Push The Matrix
+	glLoadIdentity() # Reset The Matrix
+end
+
+def viewPerspective # Set Up A Perspective View
+	glMatrixMode( GL_PROJECTION ) # Select Projection
+	glPopMatrix() # Pop The Matrix
+	glMatrixMode( GL_MODELVIEW ) # Select Modelview
+	glPopMatrix() # Pop The Matrix
+end
+
+def normalize(v)
+	len = sqrt( v[0]*v[0] + v[1]*v[1] + v[2]*v[2])
+	return v if len==0
+	[ v[0] / len, v[1] / len, v[2] / len ]
+end
+
+def calcNormal(v) # Calculates Normal For A Quad Using 3 Points
+	# Finds The Vector Between 2 Points By Subtracting
+	# The x,y,z Coordinates From One Point To Another.
+	# Calculate The Vector From Point 1 To Point 0
+	v1, v2, out = [], [], []
+	x,y,z = 0,1,2
+	
+	v1[x] = v[0][x] - v[1][x] # Vector 1.x=Vertex[0].x-Vertex[1].x 
+	v1[y] = v[0][y] - v[1][y] # Vector 1.y=Vertex[0].y-Vertex[1].y 
+	v1[z] = v[0][z] - v[1][z]	# Vector 1.z=Vertex[0].y-Vertex[1].z 
+	# Calculate The Vector From Point 2 To Point 1 
+	v2[x] = v[1][x] - v[2][x]	# Vector 2.x=Vertex[0].x-Vertex[1].x 
+	v2[y] = v[1][y] - v[2][y]	# Vector 2.y=Vertex[0].y-Vertex[1].y 
+	v2[z] = v[1][z] - v[2][z]	# Vector 2.z=Vertex[0].z-Vertex[1].z 
+	# Compute The Cross Product To Give Us A Surface Normal 
+	out[x] = v1[y]*v2[z] - v1[z]*v2[y] # Cross Product For Y - Z 
+	out[y] = v1[z]*v2[x] - v1[x]*v2[z] # Cross Product For X - Z 
+	out[z] = v1[x]*v2[y] - v1[y]*v2[x] # Cross Product For X - Y 
+
+	normalize(out)
+end
+
+def createHelix() # creates helix VA
+	twists = 5
+	r = 1.5
+
+	helix_v = []
+	helix_n = []
+	
+	0.step(360,20) do |phi| # 360 Degrees In Steps Of 20
+		0.step(360*twists,20) do |theta| # 360 Degrees * Number Of Twists In Steps Of 20
+			v= phi/180.0*PI # Calculate Angle Of First Point	(  0 ) 
+			u= theta/180.0*PI # Calculate Angle Of First Point	(  0 ) 
+
+			x= cos(u)*(2.0+cos(v))*r # Calculate x Position (1st Point) 
+			y= sin(u)*(2.0+cos(v))*r	# Calculate y Position (1st Point) 
+			z=((u-(2.0*PI)) + sin(v))*r	# Calculate z Position (1st Point) 
+
+			v0 = [x,y,z]
+
+			v= phi/180.0*PI # Calculate Angle Of Second Point	(  0 ) 
+			u= (theta+20)/180.0*PI	# Calculate Angle Of Second Point	( 20 ) 
+
+			x= cos(u)*(2.0+cos(v))*r # Calculate x Position (2nd Point)
+			y= sin(u)*(2.0+cos(v))*r	# Calculate y Position (2nd Point) 
+			z= ((u-(2.0*PI)) + sin(v))*r	# Calculate z Position (2nd Point) 
+		
+			v1 = [x,y,z]
+
+			v= (phi+20)/180.0*PI # Calculate Angle Of Third Point	( 20 ) 
+			u= (theta+20)/180.0*PI # Calculate Angle Of Third Point	( 20 ) 
+
+			x= cos(u)*(2.0+cos(v))*r # Calculate x Position (3rd Point) 
+			y= sin(u)*(2.0+cos(v))*r # Calculate y Position (3rd Point) 
+			z= ((u-(2.0*PI)) + sin(v))*r	# Calculate z Position (3rd Point) 
+
+			v2 = [x,y,z]
+
+			v= (phi+20)/180.0*PI # Calculate Angle Of Fourth Point	( 20 ) 
+			u= (theta)/180.0*PI # Calculate Angle Of Fourth Point	(  0 ) 
+
+			x= cos(u)*(2.0+cos(v))*r # Calculate x Position (4th Point) 
+			y= sin(u)*(2.0+cos(v))*r # Calculate y Position (4th Point) 
+			z= ((u-(2.0*PI)) + sin(v))*r # Calculate z Position (4th Point) 
+	
+			v3 = [x,y,z]
+
+			normal = calcNormal([v0,v1,v2,v3]) # Calculate The Quad Normal 
+			helix_v << v0 << v1 << v2 << v3
+			helix_n << normal << normal << normal << normal
+		end
+	end
+	[helix_v,helix_n]
+end
+
+def processHelix() # Draws A Helix 
+	glfMaterialColor = [0.4,0.2,0.8,1.0] # Set The Material Color
+	specular = [1.0,1.0,1.0,1.0] # Sets Up Specular Lighting
+
+	glLoadIdentity() # Reset The Modelview Matrix
+	gluLookAt(0, 5, 50, 0, 0, 0, 0, 1, 0) # Eye Position (0,5,50) Center Of Scene (0,0,0), Up On Y Axis
+
+	glPushMatrix() # Push The Modelview Matrix
+
+	glTranslatef(0,0,-50) # Translate 50 Units Into The Screen
+	glRotatef($angle/2.0,1,0,0) # Rotate By angle/2 On The X-Axis
+	glRotatef($angle/3.0,0,1,0) # Rotate By angle/3 On The Y-Axis
+
+	glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,glfMaterialColor)
+	glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,specular)
+
+	glEnableClientState(GL_VERTEX_ARRAY)
+	glEnableClientState(GL_NORMAL_ARRAY)
+	glDrawArrays(GL_QUADS,0,$helix_v.size)
+	glDisableClientState(GL_VERTEX_ARRAY)
+	glDisableClientState(GL_NORMAL_ARRAY)
+
+	glPopMatrix() # Pop The Matrix
+end
+
+def drawBlur(times,inc)
+	spost = 0.0 # Starting Texture Coordinate Offset 
+	alphainc = 0.9 / times # Fade Speed For Alpha Blending 
+	alpha = 0.2	# Starting Alpha Value 
+
+	width = glutGet(GLUT_WINDOW_WIDTH)
+	height = glutGet(GLUT_WINDOW_HEIGHT)
+	# Disable AutoTexture Coordinates 
+	glDisable(GL_TEXTURE_GEN_S)
+	glDisable(GL_TEXTURE_GEN_T)
+
+	glEnable(GL_TEXTURE_2D) # Enable 2D Texture Mapping 
+	glDisable(GL_DEPTH_TEST) # Disable Depth Testing 
+	glBlendFunc(GL_SRC_ALPHA,GL_ONE) # Set Blending Mode 
+	glEnable(GL_BLEND) # Enable Blending 
+	glBindTexture(GL_TEXTURE_2D,$blurTexture) # Bind To The Blur Texture 
+	viewOrtho() # Switch To An Ortho View 
+
+	alphainc = alpha / times # alphainc=0.2 / Times To Render Blur 
+
+	glBegin(GL_QUADS) # Begin Drawing Quads 
+	0.upto(times-1) do |num| # Number Of Times To Render Blur 
+		glColor4f(1.0, 1.0, 1.0, alpha) # Set The Alpha Value (Starts At 0.2) 
+		glTexCoord2f(0+spost,1-spost)	# Texture Coordinate	( 0, 1 ) 
+		glVertex2f(0,0)	# First Vertex		(   0,   0 ) 
+
+		glTexCoord2f(0+spost,0+spost) # Texture Coordinate	( 0, 0 ) 
+		glVertex2f(0,height) # Second Vertex	(   0, height ) 
+
+		glTexCoord2f(1-spost,0+spost) # Texture Coordinate	( 1, 0 ) 
+		glVertex2f(width,height) # Third Vertex		( width, height ) 
+
+		glTexCoord2f(1-spost,1-spost) # Texture Coordinate	( 1, 1 ) 
+		glVertex2f(width,0) # Fourth Vertex	( width,   0 ) 
+
+		spost += inc # Gradually Increase spost (Zooming Closer To Texture Center) 
+		alpha = alpha - alphainc # Gradually Decrease alpha (Gradually Fading Image Out) 
+	end
+	glEnd() # Done Drawing Quads 
+
+	viewPerspective() # Switch To A Perspective View 
+
+	glEnable(GL_DEPTH_TEST) # Enable Depth Testing 
+	glDisable(GL_TEXTURE_2D) # Disable 2D Texture Mapping 
+	glDisable(GL_BLEND) # Disable Blending 
+	glBindTexture(GL_TEXTURE_2D,0) # Unbind The Blur Texture 
+end
+
+
+def renderToTexture
+	glViewport(0,0,128,128); # Set Our Viewport (Match Texture Size)
+
+	processHelix() # Render The Helix
+
+	glBindTexture(GL_TEXTURE_2D,$blurTexture) # Bind To The Blur Texture
+
+	# Copy Our ViewPort To The Blur Texture (From 0,0 To 128,128... No Border)
+	glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 0, 0, 128, 128, 0)
+
+	glClearColor(0.0, 0.0, 0.5, 0.5) # Set The Clear Color To Medium Blue
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Clear The Screen And Depth Buffer
+	width = glutGet(GLUT_WINDOW_WIDTH)
+	height = glutGet(GLUT_WINDOW_HEIGHT)
+	glViewport(0 , 0,width,height) # Set Viewport (0,0 to widthxheight)
+end
+
+drawGLScene = lambda do # Draw The Scene
+	glClearColor(0.0, 0.0, 0.0, 0.5) # Set The Clear Color To Black
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # Clear Screen And Depth Buffer
+	glLoadIdentity() # Reset The View
+	renderToTexture() # Render To A Texture
+	processHelix() # Draw Our Helix
+	drawBlur(25,0.02) # Draw The Blur Effect 
+	glFlush() # Flush The GL Rendering Pipeline
+	glutSwapBuffers()
+	sleep(0.001) # don't hog all cpu time
+end
+
+idle = lambda do
+	now = glutGet(GLUT_ELAPSED_TIME)
+	elapsed = now - $lasttime
+	$angle += (elapsed * 0.03) # Update angle Based On The Clock 
+	$lasttime = now
+
+	glutPostRedisplay()
+end
+
+# Main
+glutInit()
+glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_ALPHA | GLUT_DEPTH)
+glutInitWindowPosition(100,100)
+glutInitWindowSize(640,480)
+glutCreateWindow("NeHe's Lesson 36")
+glutDisplayFunc(drawGLScene)
+glutIdleFunc(idle)
+glutReshapeFunc(reshape)
+glutKeyboardFunc(keyboard)
+
+init()
+
+glutMainLoop()

data/examples/OrangeBook/3Dlabs-License.txt

@@ -0,0 +1,33 @@
+Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+    Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+    Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following
+    disclaimer in the documentation and/or other materials provided
+    with the distribution.
+
+    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+    contributors may be used to endorse or promote products derived
+    from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+

data/examples/OrangeBook/brick.frag

@@ -0,0 +1,36 @@
+//
+// Fragment shader for procedural bricks
+//
+// Authors: Dave Baldwin, Steve Koren, Randi Rost
+//          based on a shader by Darwyn Peachey
+//
+// Copyright (c) 2002-2004 3Dlabs Inc. Ltd.
+//
+// See 3Dlabs-License.txt for license information
+//  
+
+uniform vec3  BrickColor, MortarColor;
+uniform vec2  BrickSize;
+uniform vec2  BrickPct;
+
+varying vec2  MCposition;
+varying float LightIntensity;
+
+void main(void)
+{
+    vec3  color;
+    vec2  position, useBrick;
+    
+    position = MCposition / BrickSize;
+
+    if (fract(position.y * 0.5) > 0.5)
+        position.x += 0.5;
+
+    position = fract(position);
+
+    useBrick = step(position, BrickPct);
+
+    color  = mix(MortarColor, BrickColor, useBrick.x * useBrick.y);
+    color *= LightIntensity;
+    gl_FragColor = vec4 (color, 1.0);
+}

data/examples/OrangeBook/brick.rb

@@ -0,0 +1,376 @@
+# Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+#    Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+#
+#    Redistributions in binary form must reproduce the above
+#    copyright notice, this list of conditions and the following
+#    disclaimer in the documentation and/or other materials provided
+#    with the distribution.
+#
+#    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
+#    contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===========================================================================
+#
+#
+# The source of the shaders itself are in plain text files. Files ending in
+# .vert are vertex shaders, and files ending in .frag are fragment shaders.
+
+require 'opengl'
+include Gl,Glu,Glut
+
+$rotl = 1 * Math::PI / 180
+$last_time = 0
+
+$fXDiff = 206
+$fYDiff = 16
+$fZDiff = 10
+$xLastIncr = 0
+$yLastIncr = 0
+$fXInertia = -0.5
+$fYInertia = 0
+$fXInertiaOld = 0
+$fYInertiaOld = 0
+$fScale = 1.0
+$ftime = 0
+$xLast = -1
+$yLast = -1
+$bmModifiers = 0
+$rotate = true
+
+INERTIA_THRESHOLD = 1.0
+INERTIA_FACTOR = 0.5
+SCALE_FACTOR = 0.01
+SCALE_INCREMENT = 0.5
+TIMER_FREQUENCY_MILLIS = 20
+
+
+$gleModel = [:cube, :teapot,:torus,:sphere]
+$clearColor = [[0,0,0,1], [0.2,0.2,0.3,1], [0.7,0.7,0.7,1]]
+
+def drawCube
+	size = 1.0
+	scale = 0.2
+	delta = 0.1
+
+	v = [
+		[ size,  size,  size * scale + delta ], 
+		[ size,  size, -size * scale + delta ], 
+		[ size, -size, -size * scale ], 
+		[ size, -size,  size * scale ],
+		[-size,  size,  size * scale + delta ],
+		[-size,  size, -size * scale + delta ],
+		[-size, -size, -size * scale ],
+		[-size, -size,  size * scale ]
+	]
+
+	cube = [
+		[ [1,0,0], v[3],v[2],v[1],v[0] ], # normal, vertices
+		[ [-1,0,0], v[6],v[7],v[4],v[5] ],
+		[ [0,0,-1], v[2],v[6],v[5],v[1] ],
+		[ [0,0,1], v[7],v[3],v[0],v[4] ],
+		[ [0,1,0], v[4],v[0],v[1],v[5] ],
+		[ [0,-1,0], v[6],v[2],v[3],v[7] ]
+	]
+
+	glBegin(GL_QUADS)
+	cube.each do |side|
+		glNormal3fv(side[0])
+
+    glTexCoord2f(1,1)
+    glVertex3fv(side[1])
+    glTexCoord2f(0,1)
+    glVertex3fv(side[2])
+    glTexCoord2f(0,0)
+    glVertex3fv(side[3])
+    glTexCoord2f(1,0)
+    glVertex3fv(side[4])
+	end
+	glEnd()
+end
+
+def nextClearColor
+	glClearColor($clearColor[0][0],
+							 $clearColor[0][1],
+							 $clearColor[0][2],
+							 $clearColor[0][3])
+	$clearColor << $clearColor.shift # rotate
+end
+
+
+play = lambda do
+	this_time = glutGet(GLUT_ELAPSED_TIME)
+
+	$rotl+=(this_time - $last_time) * -0.001
+	$last_time = this_time
+
+	glutPostRedisplay()
+end
+
+display = lambda do
+	glLoadIdentity()
+	glTranslatef(0.0, 0.0, -5.0)
+	
+	glRotatef($fYDiff, 1,0,0)
+	glRotatef($fXDiff, 0,1,0)
+	glRotatef($fZDiff, 0,0,1)
+	
+	glScalef($fScale, $fScale, $fScale)
+	
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+	
+	case $gleModel[0]
+		when :teapot :
+			glutSolidTeapot(0.6)
+		when :torus :
+			glutSolidTorus(0.2, 0.6, 64, 64)
+		when :sphere :
+			glutSolidSphere(0.6, 64, 64)
+		when :cube :
+			drawCube()
+	end
+	glFlush()
+	glutSwapBuffers()
+end
+
+key = lambda do |key,x,y|
+	case(key)
+	when ?b
+		nextClearColor()
+	when ?q, ?\e # esc
+		exit(0)
+	when ?t
+		$gleModel << $gleModel.shift # rotate the array
+	when ?\s # space
+		$rotate = !$rotate
+
+		if ($rotate==false)
+			$fXInertiaOld = $fXInertia
+			$fYInertiaOld = $fYInertia
+		else
+			$fXInertia = $fXInertiaOld
+			$fYInertia = $fYInertiaOld
+
+      # To prevent confusion, force some rotation
+			if ($fXInertia == 0 && $fYInertia == 0)
+				$fXInertia = -0.5
+			end
+		end
+	when ?+
+		$fScale += SCALE_INCREMENT
+	when ?-
+		$fScale -= SCALE_INCREMENT
+	else
+		puts "Keyboard commands:\n"
+		puts "b - Toggle among background clear colors"
+		puts "q, <esc> - Quit"
+		puts "t - Toggle among models to render"
+		puts "? - Help"
+		puts "<home>     - reset zoom and rotation"
+		puts "<space> or <click>        - stop rotation"
+		puts "<+>, <-> or <ctrl + drag> - zoom model"
+		puts "<arrow keys> or <drag>    - rotate model\n"
+	end
+end
+
+reshape = lambda do |w,h|
+	vp = 0.8
+	aspect = w.to_f/h.to_f
+	
+	glViewport(0, 0, w, h)
+	glMatrixMode(GL_PROJECTION)
+	glLoadIdentity()
+	
+	glFrustum(-vp, vp, -vp / aspect, vp / aspect, 3, 10)
+	
+	glMatrixMode(GL_MODELVIEW)
+	glLoadIdentity()
+	glTranslatef(0.0, 0.0, -5.0)
+end
+
+motion = lambda do |x,y|
+	if ($xLast != -1 || $yLast != -1)
+		$xLastIncr = x - $xLast
+		$yLastIncr = y - $yLast
+		if ($bmModifiers & GLUT_ACTIVE_CTRL != 0)
+			if ($xLast != -1)
+				$fZDiff += $xLastIncr
+				$fScale += $yLastIncr*SCALE_FACTOR
+			end
+		else
+			if ($xLast != -1)
+				$fXDiff += $xLastIncr
+				$fYDiff += $yLastIncr
+			end
+		end
+	end
+	$xLast = x
+	$yLast = y
+end
+
+mouse = lambda do |button,state,x,y|
+	$bmModifiers = glutGetModifiers()
+	if (button == GLUT_LEFT_BUTTON)
+		if (state == GLUT_UP)
+			$xLast = -1
+			$yLast = -1
+			if $xLastIncr > INERTIA_THRESHOLD
+				$fXInertia = ($xLastIncr - INERTIA_THRESHOLD)*INERTIA_FACTOR
+			end
+			if -$xLastIncr > INERTIA_THRESHOLD
+				$fXInertia = ($xLastIncr + INERTIA_THRESHOLD)*INERTIA_FACTOR
+			end
+
+			if $yLastIncr > INERTIA_THRESHOLD
+				$fYInertia = ($yLastIncr - INERTIA_THRESHOLD)*INERTIA_FACTOR
+			end
+			if -$yLastIncr > INERTIA_THRESHOLD
+				$fYInertia = ($yLastIncr + INERTIA_THRESHOLD)*INERTIA_FACTOR
+			end
+		else
+			$fXInertia = 0
+			$fYInertia = 0
+		end
+		$xLastIncr = 0
+		$yLastIncr = 0
+	end
+end
+
+special = lambda do |key,x,y|
+	case key
+	when GLUT_KEY_HOME:
+		$fXDiff = 0
+		$fYDiff = 35
+		$fZDiff = 0
+		$xLastIncr = 0
+		$yLastIncr = 0
+		$fXInertia = -0.5
+		$fYInertia = 0
+		$fScale = 1.0
+	when GLUT_KEY_LEFT:
+		$fXDiff -= 1
+	when GLUT_KEY_RIGHT:
+		$fXDiff += 1
+	when GLUT_KEY_UP:
+		$fYDiff -= 1
+	when GLUT_KEY_DOWN:
+		$fYDiff += 1
+	end
+end
+
+timer = lambda do |value|
+	$ftime += 0.01
+	if $rotate
+		$fXDiff += $fXInertia
+		$fYDiff += $fYInertia
+	end
+	glutTimerFunc(TIMER_FREQUENCY_MILLIS , timer, 0)
+end
+
+def getUniLoc(program, name)
+	loc = glGetUniformLocation(program, name)
+	
+	if (loc == -1)
+		puts "No such uniform named #{name}"
+	end
+	return loc
+end
+
+def installBrickShaders(vs_fname,fs_fname)
+	# Create a vertex shader object and a fragment shader object
+	brickVS = glCreateShader(GL_VERTEX_SHADER)
+	brickFS = glCreateShader(GL_FRAGMENT_SHADER)
+
+	# Load source code strings into shaders
+	glShaderSource(brickVS, File.read(vs_fname))
+	glShaderSource(brickFS, File.read(fs_fname))
+
+	# Compile the brick vertex shader, and print out
+	#	the compiler log file.
+	glCompileShader(brickVS)
+  vertCompiled = glGetShaderiv(brickVS, GL_COMPILE_STATUS)
+	puts "Shader InfoLog:\n#{glGetShaderInfoLog(brickVS)}\n"
+	
+	# Compile the brick fragment shader, and print out
+	# the compiler log file.
+	glCompileShader(brickFS)
+  fragCompiled = glGetShaderiv(brickFS, GL_COMPILE_STATUS)
+	puts "Shader InfoLog:\n#{glGetShaderInfoLog(brickFS)}\n"
+	
+	return false if (vertCompiled == 0 || fragCompiled == 0)
+	# Create a program object and attach the two compiled shaders
+	brickProg = glCreateProgram()
+	glAttachShader(brickProg,brickVS)
+	glAttachShader(brickProg,brickFS)
+	# Link the program object and print out the info log
+	glLinkProgram(brickProg)
+	linked = glGetProgramiv(brickProg,GL_LINK_STATUS)
+	puts "Program InfoLog:\n#{glGetProgramInfoLog(brickProg)}\n"
+	return false if linked==0
+
+	# Install program object as part of current state
+	glUseProgram(brickProg)
+
+	# Set up initial uniform values
+	glUniform3f(getUniLoc(brickProg, "BrickColor"), 1.0, 0.3, 0.2)
+	glUniform3f(getUniLoc(brickProg, "MortarColor"), 0.85, 0.86, 0.84)
+	glUniform2f(getUniLoc(brickProg, "BrickSize"), 0.30, 0.15)
+	glUniform2f(getUniLoc(brickProg, "BrickPct"), 0.90, 0.85)
+	glUniform3f(getUniLoc(brickProg, "LightPosition"), 0.0, 0.0, 4.0)
+
+	return true
+end
+
+# Main
+
+glutInit()
+glutInitDisplayMode( GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE)
+glutInitWindowPosition(100,100)
+glutInitWindowSize(500, 500)
+glutCreateWindow( "3Dlabs Brick Shader")
+
+glutIdleFunc(play)
+glutDisplayFunc(display)
+glutKeyboardFunc(key)
+glutReshapeFunc(reshape)
+glutMotionFunc(motion)
+glutMouseFunc(mouse)
+glutSpecialFunc(special)
+glutTimerFunc(TIMER_FREQUENCY_MILLIS , timer, 0)
+ 
+# Make sure that OpenGL 2.0 is supported by the driver
+if Gl.is_available?(2.0)==false
+	major,minor,*rest = glGetString(GL_VERSION).split(/\.| /)
+	puts "GL_VERSION major=#{major} minor=#{minor}"
+	puts "Support for OpenGL 2.0 is required for this demo...exiting"
+	exit(1)
+end
+
+glDepthFunc(GL_LESS)
+glEnable(GL_DEPTH_TEST)
+
+nextClearColor()
+
+key.call('?', 0, 0)
+ 
+success = installBrickShaders("brick.vert","brick.frag")
+glutMainLoop() if success == true