ruby-opengl 0.60.1 → 0.61.0

data/examples/NeHe/nehe_lesson36.rb

@@ -1,303 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-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

@@ -1,36 +0,0 @@
-//
-// 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

@@ -1,376 +0,0 @@
-# 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