diff -ru opengl-0.32c-orig/extconf.rb opengl-0.32c/extconf.rb
--- opengl-0.32c-orig/extconf.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/extconf.rb	Mon Dec 22 21:15:53 2003
@@ -98,7 +98,10 @@
 install: #{modules}
 #{"\t@$(MAKE) -f Makefile.ogl install" if (ogl_flg)}
 #{"\t@$(MAKE) -f Makefile.glut install" if (glut_flg)}
-
+	mkdir -p ${prefix}/share/doc/opengl-rb18/sample
+	rm sample/aaindex.rb sample/aapoly.rb
+	cp sample/*.rb ${prefix}/share/doc/opengl-rb18/sample
+	
 site-install: #{modules}
 #{"\t@$(MAKE) -f Makefile.ogl site-install" if (ogl_flg)}
 #{"\t@$(MAKE) -f Makefile.glut site-install" if (glut_flg)}
diff -ru opengl-0.32c-orig/sample/accanti.rb opengl-0.32c/sample/accanti.rb
--- opengl-0.32c-orig/sample/accanti.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/accanti.rb	Mon Dec 22 20:31:25 2003
@@ -41,6 +41,8 @@
 # */
 require "opengl"
 require "glut"
+
+$LOAD_PATH.push(File.dirname($0))  # Find jitter in script directory
 require "jitter"
 
 #/*  Initialize lighting and other values.
@@ -73,7 +75,7 @@
     sphere_diffuse = [ 0.7, 0.0, 0.7, 1.0 ];
     octa_diffuse = [ 0.7, 0.4, 0.4, 1.0 ];
     
-    GL::PushMatrix ();
+    GL::PushMatrix();
     GL::Rotate(30.0, 1.0, 0.0, 0.0);
 
     GL::PushMatrix();
@@ -83,28 +85,28 @@
     GLUT::SolidTorus(0.275, 0.85, 16, 16);
     GL::PopMatrix();
 
-    GL::PushMatrix ();
+    GL::PushMatrix();
     GL::Translate(-0.75, -0.50, 0.0); 
     GL::Rotate(45.0, 0.0, 0.0, 1.0);
     GL::Rotate(45.0, 1.0, 0.0, 0.0);
     GL::Material(GL::FRONT, GL::DIFFUSE, cube_diffuse);
     GLUT::SolidCube (1.5);
-    GL::PopMatrix ();
+    GL::PopMatrix();
 
-    GL::PushMatrix ();
+    GL::PushMatrix();
     GL::Translate(0.75, 0.60, 0.0); 
     GL::Rotate(30.0, 1.0, 0.0, 0.0);
     GL::Material(GL::FRONT, GL::DIFFUSE, sphere_diffuse);
-    GLUT::SolidSphere (1.0, 16, 16);
-    GL::PopMatrix ();
+    GLUT::SolidSphere(1.0, 16, 16);
+    GL::PopMatrix();
 
-    GL::PushMatrix ();
+    GL::PushMatrix();
     GL::Translate(0.70, -0.90, 0.25); 
     GL::Material(GL::FRONT, GL::DIFFUSE, octa_diffuse);
-    GLUT::SolidOctahedron ();
-    GL::PopMatrix ();
+    GLUT::SolidOctahedron();
+    GL::PopMatrix();
 
-    GL::PopMatrix ();
+    GL::PopMatrix();
 end
 
 ACSIZE=8
@@ -115,7 +117,7 @@
     GL::Clear(GL::ACCUM_BUFFER_BIT);
     for jitter in 0...ACSIZE
 	GL::Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT);
-	GL::PushMatrix ();
+	GL::PushMatrix();
 #/*	Note that 4.5 is the distance in world space between
 # *	left and right and bottom and top.
 # *	This formula converts fractional pixel movement to 
@@ -123,11 +125,11 @@
 # */
 	GL::Translate($j8[jitter][0]*4.5/viewport[2],
 	    $j8[jitter][1]*4.5/viewport[3], 0.0);
-	displayObjects ();
-	GL::PopMatrix ();
+	displayObjects();
+	GL::PopMatrix();
 	GL::Accum(GL::ACCUM, 1.0/ACSIZE);
     end
-    GL::Accum (GL::RETURN, 1.0);
+    GL::Accum(GL::RETURN, 1.0);
     GL::Flush();
 }
 
@@ -136,9 +138,9 @@
     GL::MatrixMode(GL::PROJECTION);
     GL::LoadIdentity();
     if (w <= h) 
-	GL::Ortho (-2.25, 2.25, -2.25*h/w, 2.25*h/w, -10.0, 10.0);
+	GL::Ortho(-2.25, 2.25, -2.25*h/w, 2.25*h/w, -10.0, 10.0);
     else 
-	GL::Ortho (-2.25*w/h, 2.25*w/h, -2.25, 2.25, -10.0, 10.0);
+	GL::Ortho(-2.25*w/h, 2.25*w/h, -2.25, 2.25, -10.0, 10.0);
     end
     GL::MatrixMode(GL::MODELVIEW);
 }
@@ -148,10 +150,10 @@
 #  *  RGBA display mode, and handle input events.
 #  */
     GLUT.Init
-    GLUT::InitDisplayMode (GLUT::SINGLE | GLUT::RGB | GLUT::ACCUM | GLUT::DEPTH);
-    GLUT::InitWindowSize (250, 250);
-    GLUT::CreateWindow ($0)
+    GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB | GLUT::ACCUM | GLUT::DEPTH);
+    GLUT::InitWindowSize(250, 250);
+    GLUT::CreateWindow($0)
     myinit();
-    GLUT::ReshapeFunc (myReshape);
+    GLUT::ReshapeFunc(myReshape);
     GLUT::DisplayFunc(display);
     GLUT::MainLoop();
diff -ru opengl-0.32c-orig/sample/accpersp.rb opengl-0.32c/sample/accpersp.rb
--- opengl-0.32c-orig/sample/accpersp.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/accpersp.rb	Mon Dec 22 20:36:59 2003
@@ -42,6 +42,8 @@
 # */
 require "opengl"
 require "glut"
+
+$LOAD_PATH.push(File.dirname($0))  # Find jitter in script directory
 require "jitter"
 
 PI_=3.14159265358979323846
@@ -134,39 +136,39 @@
    sphere_diffuse = [ 0.7, 0.0, 0.7, 1.0 ];
    octa_diffuse = [ 0.7, 0.4, 0.4, 1.0 ];
     
-   GL::PushMatrix ();
+   GL::PushMatrix();
    GL::Translate(0.0, 0.0, -5.0); 
    GL::Rotate(30.0, 1.0, 0.0, 0.0);
 
-   GL::PushMatrix ();
+   GL::PushMatrix();
    GL::Translate(-0.80, 0.35, 0.0); 
    GL::Rotate(100.0, 1.0, 0.0, 0.0);
    GL::Material(GL::FRONT, GL::DIFFUSE, torus_diffuse);
-   GLUT::SolidTorus (0.275, 0.85, 16, 16);
-   GL::PopMatrix ();
+   GLUT::SolidTorus(0.275, 0.85, 16, 16);
+   GL::PopMatrix();
 
-   GL::PushMatrix ();
+   GL::PushMatrix();
    GL::Translate(-0.75, -0.50, 0.0); 
    GL::Rotate(45.0, 0.0, 0.0, 1.0);
    GL::Rotate(45.0, 1.0, 0.0, 0.0);
    GL::Material(GL::FRONT, GL::DIFFUSE, cube_diffuse);
-   GLUT::SolidCube (1.5);
-   GL::PopMatrix ();
+   GLUT::SolidCube(1.5);
+   GL::PopMatrix();
 
-   GL::PushMatrix ();
+   GL::PushMatrix();
    GL::Translate(0.75, 0.60, 0.0); 
    GL::Rotate(30.0, 1.0, 0.0, 0.0);
    GL::Material(GL::FRONT, GL::DIFFUSE, sphere_diffuse);
-   GLUT::SolidSphere (1.0, 16, 16);
-   GL::PopMatrix ();
+   GLUT::SolidSphere(1.0, 16, 16);
+   GL::PopMatrix();
 
-   GL::PushMatrix ();
+   GL::PushMatrix();
    GL::Translate(0.70, -0.90, 0.25); 
    GL::Material(GL::FRONT, GL::DIFFUSE, octa_diffuse);
-   GLUT::SolidOctahedron ();
-   GL::PopMatrix ();
+   GLUT::SolidOctahedron();
+   GL::PopMatrix();
 
-   GL::PopMatrix ();
+   GL::PopMatrix();
 end
 
 ACSIZE=8
@@ -177,12 +179,12 @@
    GL::Clear(GL::ACCUM_BUFFER_BIT);
    for jitter in 0...ACSIZE
       GL::Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT);
-      accPerspective (50.0, viewport[2]/ viewport[3], 
+      accPerspective(50.0, viewport[2]/ viewport[3], 
          1.0, 15.0, $j8[jitter][0], $j8[jitter][1], 0.0, 0.0, 1.0);
-      displayObjects ();
+      displayObjects();
       GL::Accum(GL::ACCUM, 1.0/ACSIZE);
    end
-   GL::Accum (GL::RETURN, 1.0);
+   GL::Accum(GL::RETURN, 1.0);
    GL::Flush();
 }
 
@@ -202,10 +204,10 @@
 # *  Be certain you request an accumulation buffer.
 # */
    GLUT.Init
-   GLUT::InitDisplayMode (GLUT::SINGLE | GLUT::RGB | GLUT::ACCUM | GLUT::DEPTH);
-   GLUT::InitWindowSize (250, 250);
-   GLUT::InitWindowPosition (100, 100);
-   GLUT::CreateWindow ($0)
+   GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB | GLUT::ACCUM | GLUT::DEPTH);
+   GLUT::InitWindowSize(250, 250);
+   GLUT::InitWindowPosition(100, 100);
+   GLUT::CreateWindow($0)
    init();
    GLUT::ReshapeFunc(reshape);
    GLUT::DisplayFunc(display);
diff -ru opengl-0.32c-orig/sample/alpha3D.rb opengl-0.32c/sample/alpha3D.rb
--- opengl-0.32c-orig/sample/alpha3D.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/alpha3D.rb	Mon Dec 22 20:38:30 2003
@@ -70,12 +70,12 @@
 
    $sphereList = GL::GenLists(1);
    GL::NewList($sphereList, GL::COMPILE);
-      GLUT::SolidSphere (0.4, 16, 16);
+      GLUT::SolidSphere(0.4, 16, 16);
    GL::EndList();
 
    $cubeList = GL::GenLists(1);
    GL::NewList($cubeList, GL::COMPILE);
-      GLUT::SolidCube (0.6);
+      GLUT::SolidCube(0.6);
    GL::EndList();
 end
 
@@ -85,28 +85,28 @@
    mat_transparent = [ 0.0, 0.8, 0.8, 0.6 ];
    mat_emission = [ 0.0, 0.3, 0.3, 0.6 ];
 
-   GL::Clear (GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT);
+   GL::Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT);
 
-   GL::PushMatrix ();
+   GL::PushMatrix();
       GL::Translate(-0.15, -0.15, $solidZ);
       GL::Material(GL::FRONT, GL::EMISSION, mat_zero);
       GL::Material(GL::FRONT, GL::DIFFUSE, mat_solid);
-      GL::CallList ($sphereList);
-   GL::PopMatrix ();
+      GL::CallList($sphereList);
+   GL::PopMatrix();
 
-   GL::PushMatrix ();
+   GL::PushMatrix();
       GL::Translate(0.15, 0.15, $transparentZ);
       GL::Rotate(15.0, 1.0, 1.0, 0.0);
       GL::Rotate(30.0, 0.0, 1.0, 0.0);
       GL::Material(GL::FRONT, GL::EMISSION, mat_emission);
       GL::Material(GL::FRONT, GL::DIFFUSE, mat_transparent);
-      GL::Enable (GL::BLEND);
-      GL::DepthMask (GL::FALSE);
-      GL::BlendFunc (GL::SRC_ALPHA, GL::ONE);
-      GL::CallList ($cubeList);
-      GL::DepthMask (GL::TRUE);
-      GL::Disable (GL::BLEND);
-   GL::PopMatrix ();
+      GL::Enable(GL::BLEND);
+      GL::DepthMask(GL::FALSE);
+      GL::BlendFunc(GL::SRC_ALPHA, GL::ONE);
+      GL::CallList($cubeList);
+      GL::DepthMask(GL::TRUE);
+      GL::Disable(GL::BLEND);
+   GL::PopMatrix();
 
    GL::Flush();
 }
@@ -116,10 +116,10 @@
    GL::MatrixMode(GL::PROJECTION);
    GL::LoadIdentity();
    if (w <= h)
-      GL::Ortho (-1.5, 1.5, -1.5*h.to_f/w,
+      GL::Ortho(-1.5, 1.5, -1.5*h.to_f/w,
                1.5*h.to_f/w, -10.0, 10.0);
    else
-      GL::Ortho (-1.5*w.to_f/h,
+      GL::Ortho(-1.5*w.to_f/h,
                1.5*w.to_f/h, -1.5, 1.5, -10.0, 10.0);
    end
    GL::MatrixMode(GL::MODELVIEW);
diff -ru opengl-0.32c-orig/sample/bezcurve.rb opengl-0.32c/sample/bezcurve.rb
--- opengl-0.32c-orig/sample/bezcurve.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/bezcurve.rb	Mon Dec 22 20:39:11 2003
@@ -94,12 +94,12 @@
 }
 
    GLUT::Init();
-   GLUT::InitDisplayMode (GLUT::SINGLE | GLUT::RGB);
-   GLUT::InitWindowSize (500, 500);
-   GLUT::InitWindowPosition (100, 100);
+   GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB);
+   GLUT::InitWindowSize(500, 500);
+   GLUT::InitWindowPosition(100, 100);
    GLUT::CreateWindow();
-   init ();
+   init();
    GLUT::DisplayFunc(display);
    GLUT::ReshapeFunc(reshape);
-   GLUT::KeyboardFunc (keyboard);
+   GLUT::KeyboardFunc(keyboard);
    GLUT::MainLoop();
diff -ru opengl-0.32c-orig/sample/dof.rb opengl-0.32c/sample/dof.rb
--- opengl-0.32c-orig/sample/dof.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/dof.rb	Mon Dec 22 20:43:56 2003
@@ -48,6 +48,8 @@
 # */
 require "opengl"
 require "glut"
+
+$LOAD_PATH.push(File.dirname($0))  # Find jitter in script directory
 require "jitter"
 
 PI_=3.14159265358979323846
@@ -130,14 +132,14 @@
     GL::LightModel(GL::LIGHT_MODEL_AMBIENT, lmodel_ambient);
     GL::LightModel(GL::LIGHT_MODEL_LOCAL_VIEWER, local_view);
 
-    GL::FrontFace (GL::CW);
+    GL::FrontFace(GL::CW);
     GL::Enable(GL::LIGHTING);
     GL::Enable(GL::LIGHT0);
     GL::Enable(GL::AUTO_NORMAL);
     GL::Enable(GL::NORMALIZE);
 
-    GL::MatrixMode (GL::MODELVIEW);
-    GL::LoadIdentity ();
+    GL::MatrixMode(GL::MODELVIEW);
+    GL::LoadIdentity();
 
     GL::ClearColor(0.0, 0.0, 0.0, 0.0);
     GL::ClearAccum(0.0, 0.0, 0.0, 0.0);
@@ -166,30 +168,30 @@
 # *  In this example, the teapots are drawn 8 times.  See jitter.h
 # */
 display = proc {
-    viewport = GL::GetDoublev (GL::VIEWPORT);
+    viewport = GL::GetDoublev(GL::VIEWPORT);
     GL::Clear(GL::ACCUM_BUFFER_BIT);
 
     for jitter in 0...8
 	GL::Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT);
-	accPerspective (45.0, 
+	accPerspective(45.0, 
 		 viewport[2]/ viewport[3], 
 		1.0, 15.0, 0.0, 0.0,
 		0.33*$j8[jitter][0], 0.33*$j8[jitter][1], 5.0);
 #/*	ruby, gold, silver, emerald, and cyan teapots	*/
-	renderTeapot (-1.1, -0.5, -4.5, 0.1745, 0.01175, 0.01175,
+	renderTeapot(-1.1, -0.5, -4.5, 0.1745, 0.01175, 0.01175,
 	    0.61424, 0.04136, 0.04136, 0.727811, 0.626959, 0.626959, 0.6);
-	renderTeapot (-0.5, -0.5, -5.0, 0.24725, 0.1995, 0.0745,
+	renderTeapot(-0.5, -0.5, -5.0, 0.24725, 0.1995, 0.0745,
 	    0.75164, 0.60648, 0.22648, 0.628281, 0.555802, 0.366065, 0.4);
-	renderTeapot (0.2, -0.5, -5.5, 0.19225, 0.19225, 0.19225,
+	renderTeapot(0.2, -0.5, -5.5, 0.19225, 0.19225, 0.19225,
 	    0.50754, 0.50754, 0.50754, 0.508273, 0.508273, 0.508273, 0.4);
-	renderTeapot (1.0, -0.5, -6.0, 0.0215, 0.1745, 0.0215, 
+	renderTeapot(1.0, -0.5, -6.0, 0.0215, 0.1745, 0.0215, 
 	    0.07568, 0.61424, 0.07568, 0.633, 0.727811, 0.633, 0.6);
-	renderTeapot (1.8, -0.5, -6.5, 0.0, 0.1, 0.06, 0.0, 0.50980392, 
+	renderTeapot(1.8, -0.5, -6.5, 0.0, 0.1, 0.06, 0.0, 0.50980392, 
 	    0.50980392, 0.50196078, 0.50196078, 0.50196078, 0.25);
-	GL::Accum (GL::ACCUM, 0.125);
+	GL::Accum(GL::ACCUM, 0.125);
     end
 
-    GL::Accum (GL::RETURN, 1.0);
+    GL::Accum(GL::RETURN, 1.0);
     GL::Flush();
 }
 
@@ -202,7 +204,7 @@
 # *  RGBA display mode, depth buffer, and handle input events.
 # */
     GLUT::Init();
-    GLUT::InitDisplayMode (GLUT::SINGLE | GLUT::RGB | GLUT::ACCUM | GLUT::DEPTH);
+    GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB | GLUT::ACCUM | GLUT::DEPTH);
     GLUT::CreateWindow()
     myinit();
     GLUT::ReshapeFunc(myReshape);
diff -ru opengl-0.32c-orig/sample/feedback.rb opengl-0.32c/sample/feedback.rb
--- opengl-0.32c-orig/sample/feedback.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/feedback.rb	Mon Dec 22 20:45:48 2003
@@ -57,35 +57,35 @@
 # * is issued between the each primitive.
 # */
 def drawGeometry(mode)
-   GL::Begin (GL::LINE_STRIP);
+   GL::Begin(GL::LINE_STRIP);
    GL::Normal(0.0, 0.0, 1.0);
    GL::Vertex(30.0, 30.0, 0.0);
    GL::Vertex(50.0, 60.0, 0.0);
    GL::Vertex(70.0, 40.0, 0.0);
-   GL::End ();
+   GL::End();
    if (mode == GL::FEEDBACK)
-      GL::PassThrough (1.0);
+      GL::PassThrough(1.0);
    end
-   GL::Begin (GL::POINTS);
+   GL::Begin(GL::POINTS);
    GL::Vertex(-100.0, -100.0, -100.0);  # /*  will be clipped  */
-   GL::End ();
+   GL::End();
    if (mode == GL::FEEDBACK)
-      GL::PassThrough (2.0);
+      GL::PassThrough(2.0);
    end
-   GL::Begin (GL::POINTS);
+   GL::Begin(GL::POINTS);
    GL::Normal(0.0, 0.0, 1.0);
    GL::Vertex(50.0, 50.0, 0.0);
-   GL::End ();
+   GL::End();
 end
 
 # /* Write contents of one vertex to stdout.	*/
 def print3DcolorVertex(size, count, buffer)
-   printf ("  ");
+   printf("  ");
    for i in 0...7
-      printf ("%4.2f ", buffer[size-count]);
+      printf("%4.2f ", buffer[size-count]);
       count = count - 1;
    end
-   printf ("\n");
+   printf("\n");
    return count
 end
 
@@ -96,38 +96,38 @@
    while (count!=0)
       token = buffer[size-count]; count-=1;
       if (token == GL::PASS_THROUGH_TOKEN)
-         printf ("GL::PASS_THROUGH_TOKEN\n");
-         printf ("  %4.2f\n", buffer[size-count]);
+         printf("GL::PASS_THROUGH_TOKEN\n");
+         printf("  %4.2f\n", buffer[size-count]);
          count-=1;
       elsif (token == GL::POINT_TOKEN)
-         printf ("GL::POINT_TOKEN\n");
-         count = print3DcolorVertex (size, count, buffer);
+         printf("GL::POINT_TOKEN\n");
+         count = print3DcolorVertex(size, count, buffer);
       elsif (token == GL::LINE_TOKEN)
-         printf ("GL::LINE_TOKEN\n");
-         count = print3DcolorVertex (size, count, buffer);
-         count = print3DcolorVertex (size, count, buffer);
+         printf("GL::LINE_TOKEN\n");
+         count = print3DcolorVertex(size, count, buffer);
+         count = print3DcolorVertex(size, count, buffer);
       elsif (token == GL::LINE_RESET_TOKEN)
-         printf ("GL::LINE_RESET_TOKEN\n");
-         count = print3DcolorVertex (size, count, buffer);
-         count = print3DcolorVertex (size, count, buffer);
+         printf("GL::LINE_RESET_TOKEN\n");
+         count = print3DcolorVertex(size, count, buffer);
+         count = print3DcolorVertex(size, count, buffer);
       end
    end
 end
 
 display = proc {
-   GL::MatrixMode (GL::PROJECTION);
-   GL::LoadIdentity ();
-   GL::Ortho (0.0, 100.0, 0.0, 100.0, 0.0, 1.0);
+   GL::MatrixMode(GL::PROJECTION);
+   GL::LoadIdentity();
+   GL::Ortho(0.0, 100.0, 0.0, 100.0, 0.0, 1.0);
 
-   GL::ClearColor (0.0, 0.0, 0.0, 0.0);
+   GL::ClearColor(0.0, 0.0, 0.0, 0.0);
    GL::Clear(GL::COLOR_BUFFER_BIT);
-   drawGeometry (GL::RENDER);
+   drawGeometry(GL::RENDER);
 
    feedBuffer = GL::FeedbackBuffer(1024, GL::GL_3D_COLOR);
-   GL::RenderMode (GL::FEEDBACK);
-   drawGeometry (GL::FEEDBACK);
+   GL::RenderMode(GL::FEEDBACK);
+   drawGeometry(GL::FEEDBACK);
 
-   size = GL::RenderMode (GL::RENDER);
+   size = GL::RenderMode(GL::RENDER);
    printBuffer(size, feedBuffer.unpack("f#{size}"));
 }
 
@@ -141,10 +141,10 @@
 
    GLUT::Init()
    GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB);
-   GLUT::InitWindowSize (100, 100);
-   GLUT::InitWindowPosition (100, 100);
+   GLUT::InitWindowSize(100, 100);
+   GLUT::InitWindowPosition(100, 100);
    GLUT::CreateWindow()
    init();
    GLUT::DisplayFunc(display);
-   GLUT::KeyboardFunc (keyboard);
+   GLUT::KeyboardFunc(keyboard);
    GLUT::MainLoop();
diff -ru opengl-0.32c-orig/sample/font.rb opengl-0.32c/sample/font.rb
--- opengl-0.32c-orig/sample/font.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/font.rb	Mon Dec 22 20:46:38 2003
@@ -81,7 +81,7 @@
 def makeRasterFont
    GL::PixelStorei(GL::UNPACK_ALIGNMENT, 1);
 
-   $fontOffset = GL::GenLists (128);
+   $fontOffset = GL::GenLists(128);
    i = 0; j = ?A;
    for i in 0...26
       GL::NewList($fontOffset + j, GL::COMPILE);
@@ -95,15 +95,15 @@
 end
 
 def init
-   GL::ShadeModel (GL::FLAT);
+   GL::ShadeModel(GL::FLAT);
    makeRasterFont();
 end
 
 def printString(s)
-   GL::PushAttrib (GL::LIST_BIT);
+   GL::PushAttrib(GL::LIST_BIT);
    GL::ListBase($fontOffset);
    GL::CallLists(s);
-   GL::PopAttrib ();
+   GL::PopAttrib();
 end
 
 #/* Everything above this line could be in a library 
@@ -121,14 +121,14 @@
    printString("THE QUICK BROWN FOX JUMPS");
    GL::RasterPos(20, 40);
    printString("OVER A LAZY DOG");
-   GL::Flush ();
+   GL::Flush();
 }
 
 reshape = proc {|w, h|
    GL::Viewport(0, 0,  w,  h);
    GL::MatrixMode(GL::PROJECTION);
    GL::LoadIdentity();
-   GL::Ortho (0.0, w, 0.0, h, -1.0, 1.0);
+   GL::Ortho(0.0, w, 0.0, h, -1.0, 1.0);
    GL::MatrixMode(GL::MODELVIEW);
 }
 
@@ -147,7 +147,7 @@
    GLUT::Init();
    GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB);
    GLUT::InitWindowSize(300, 100);
-   GLUT::InitWindowPosition (100, 100);
+   GLUT::InitWindowPosition(100, 100);
    GLUT::CreateWindow();
    init();
    GLUT::ReshapeFunc(reshape);
diff -ru opengl-0.32c-orig/sample/material.rb opengl-0.32c/sample/material.rb
--- opengl-0.32c-orig/sample/material.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/material.rb	Mon Dec 22 20:47:53 2003
@@ -264,10 +264,10 @@
     GL::MatrixMode(GL::PROJECTION);
     GL::LoadIdentity();
     if (w <= (h * 2))
-	GL::Ortho (-6.0, 6.0, -3.0*(h.to_f*2)/w, 
+	GL::Ortho(-6.0, 6.0, -3.0*(h.to_f*2)/w, 
 	    3.0*(h.to_f*2)/w, -10.0, 10.0);
     else
-	GL::Ortho (-6.0*w.to_f/(h*2), 
+	GL::Ortho(-6.0*w.to_f/(h*2), 
 	    6.0*w.to_f/(h*2), -3.0, 3.0, -10.0, 10.0);
     end
     GL::MatrixMode(GL::MODELVIEW);
@@ -278,8 +278,8 @@
 # *  RGBA display mode, and handle input events.
 # */
     GLUT::Init();
-    GLUT::InitDisplayMode (GLUT::SINGLE | GLUT::RGB | GLUT::DEPTH);
-    GLUT::InitWindowSize (600, 450);
+    GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB | GLUT::DEPTH);
+    GLUT::InitWindowSize(600, 450);
     GLUT::CreateWindow();
     myinit();
     GLUT::ReshapeFunc(myReshape);
diff -ru opengl-0.32c-orig/sample/pickdepth.rb opengl-0.32c/sample/pickdepth.rb
--- opengl-0.32c-orig/sample/pickdepth.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/pickdepth.rb	Mon Dec 22 20:50:32 2003
@@ -100,19 +100,19 @@
 # *  selection array.
 # */
 def processHits(hits, buffer)
-   printf ("hits = %d\n", hits);
+   printf("hits = %d\n", hits);
    ptr = buffer.unpack("I*")
    p = 0
    for i in 0...hits 	#/*  for each hit  */
       names = ptr[p]
-      printf (" number of names for hit = %d\n", names); p+=1;
+      printf(" number of names for hit = %d\n", names); p+=1;
       printf("  z1 is %g;",  ptr[p].to_f/0xffffffff); p+=1;
       printf(" z2 is %g\n",  ptr[p].to_f/0xffffffff); p+=1;
-      printf ("   the name is ");
+      printf("   the name is ");
       for j in 0...names  #	/*  for each name */
-         printf ("%d ", ptr[p]); p+=1
+         printf("%d ", ptr[p]); p+=1
       end
-      printf ("\n");
+      printf("\n");
    end
 end
 
diff -ru opengl-0.32c-orig/sample/select.rb opengl-0.32c/sample/select.rb
--- opengl-0.32c-orig/sample/select.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/select.rb	Mon Dec 22 20:52:41 2003
@@ -104,33 +104,33 @@
 
    GL::MatrixMode(GL::MODELVIEW);
    GL::LoadIdentity();
-   GLU::LookAt (7.5, 7.5, 12.5, 2.5, 2.5, -5.0, 0.0, 1.0, 0.0);
+   GLU::LookAt(7.5, 7.5, 12.5, 2.5, 2.5, -5.0, 0.0, 1.0, 0.0);
    GL::Color(0.0, 1.0, 0.0);#	/*  green triangle	*/
-   drawTriangle (2.0, 2.0, 3.0, 2.0, 2.5, 3.0, -5.0);
+   drawTriangle(2.0, 2.0, 3.0, 2.0, 2.5, 3.0, -5.0);
    GL::Color(1.0, 0.0, 0.0);#	/*  red triangle	*/
-   drawTriangle (2.0, 7.0, 3.0, 7.0, 2.5, 8.0, -5.0);
+   drawTriangle(2.0, 7.0, 3.0, 7.0, 2.5, 8.0, -5.0);
    GL::Color(1.0, 1.0, 0.0);#	/*  yellow triangles	*/
-   drawTriangle (2.0, 2.0, 3.0, 2.0, 2.5, 3.0, 0.0);
-   drawTriangle (2.0, 2.0, 3.0, 2.0, 2.5, 3.0, -10.0);
-   drawViewVolume (0.0, 5.0, 0.0, 5.0, 0.0, 10.0);
+   drawTriangle(2.0, 2.0, 3.0, 2.0, 2.5, 3.0, 0.0);
+   drawTriangle(2.0, 2.0, 3.0, 2.0, 2.5, 3.0, -10.0);
+   drawViewVolume(0.0, 5.0, 0.0, 5.0, 0.0, 10.0);
 end
 
 #/* processHits prints out the contents of the selection array
 # */
 def processHits(hits, buffer)
-   printf ("hits = %d\n", hits);
+   printf("hits = %d\n", hits);
    ptr = buffer.unpack("I*")
    p = 0
    for i in 0...hits 	#/*  for each hit  */
       names = ptr[p]
-      printf (" number of names for hit = %d\n", names); p+=1;
+      printf(" number of names for hit = %d\n", names); p+=1;
       printf("  z1 is %g;",  ptr[p].to_f/0xffffffff); p+=1;
       printf(" z2 is %g\n",  ptr[p].to_f/0xffffffff); p+=1;
-      printf ("   the name is ");
+      printf("   the name is ");
       for j in 0...names  #	/*  for each name */
-         printf ("%d ", ptr[p]); p+=1
+         printf("%d ", ptr[p]); p+=1
       end
-      printf ("\n");
+      printf("\n");
    end
 end
 
@@ -146,29 +146,29 @@
 def selectObjects
 
    selectBuf = GL::SelectBuffer(BUFSIZE);
-   GL::RenderMode (GL::SELECT);
+   GL::RenderMode(GL::SELECT);
 
    GL::InitNames();
    GL::PushName(0);
 
-   GL::PushMatrix ();
-   GL::MatrixMode (GL::PROJECTION);
-   GL::LoadIdentity ();
-   GL::Ortho (0.0, 5.0, 0.0, 5.0, 0.0, 10.0);
-   GL::MatrixMode (GL::MODELVIEW);
-   GL::LoadIdentity ();
+   GL::PushMatrix();
+   GL::MatrixMode(GL::PROJECTION);
+   GL::LoadIdentity();
+   GL::Ortho(0.0, 5.0, 0.0, 5.0, 0.0, 10.0);
+   GL::MatrixMode(GL::MODELVIEW);
+   GL::LoadIdentity();
    GL::LoadName(1);
-   drawTriangle (2.0, 2.0, 3.0, 2.0, 2.5, 3.0, -5.0);
+   drawTriangle(2.0, 2.0, 3.0, 2.0, 2.5, 3.0, -5.0);
    GL::LoadName(2);
-   drawTriangle (2.0, 7.0, 3.0, 7.0, 2.5, 8.0, -5.0);
+   drawTriangle(2.0, 7.0, 3.0, 7.0, 2.5, 8.0, -5.0);
    GL::LoadName(3);
-   drawTriangle (2.0, 2.0, 3.0, 2.0, 2.5, 3.0, 0.0);
-   drawTriangle (2.0, 2.0, 3.0, 2.0, 2.5, 3.0, -10.0);
-   GL::PopMatrix ();
-   GL::Flush ();
+   drawTriangle(2.0, 2.0, 3.0, 2.0, 2.5, 3.0, 0.0);
+   drawTriangle(2.0, 2.0, 3.0, 2.0, 2.5, 3.0, -10.0);
+   GL::PopMatrix();
+   GL::Flush();
 
    hits = GL::RenderMode(GL::RENDER);
-   processHits (hits, selectBuf);
+   processHits(hits, selectBuf);
 end 
 
 def init
@@ -177,10 +177,10 @@
 end
 
 display = proc {
-   GL::ClearColor (0.0, 0.0, 0.0, 0.0);
+   GL::ClearColor(0.0, 0.0, 0.0, 0.0);
    GL::Clear(GL::COLOR_BUFFER_BIT | GL::DEPTH_BUFFER_BIT);
-   drawScene ();
-   selectObjects ();
+   drawScene();
+   selectObjects();
    GL::Flush();
 }
 
@@ -195,9 +195,9 @@
 #/*  Main Loop  */
 
    GLUT.Init
-   GLUT::InitDisplayMode (GLUT::SINGLE | GLUT::RGB | GLUT::DEPTH);
-   GLUT::InitWindowSize (200, 200);
-   GLUT::InitWindowPosition (100, 100);
+   GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB | GLUT::DEPTH);
+   GLUT::InitWindowSize(200, 200);
+   GLUT::InitWindowPosition(100, 100);
    GLUT::CreateWindow $0
    init();
    GLUT::DisplayFunc(display);
diff -ru opengl-0.32c-orig/sample/texturesurf.rb opengl-0.32c/sample/texturesurf.rb
--- opengl-0.32c-orig/sample/texturesurf.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/texturesurf.rb	Mon Dec 22 20:56:01 2003
@@ -101,7 +101,7 @@
     GL::Enable(GL::TEXTURE_2D);
     GL::Enable(GL::DEPTH_TEST);
     GL::Enable(GL::NORMALIZE);
-    GL::ShadeModel (GL::FLAT);
+    GL::ShadeModel(GL::FLAT);
 end
 
 myReshape = proc {|w, h|
@@ -119,9 +119,9 @@
 }
 
     GLUT::Init();
-    GLUT::InitDisplayMode (GLUT::SINGLE | GLUT::RGB | GLUT::DEPTH);
-    GLUT::CreateWindow ();
+    GLUT::InitDisplayMode(GLUT::SINGLE | GLUT::RGB | GLUT::DEPTH);
+    GLUT::CreateWindow();
     myinit();
-    GLUT::ReshapeFunc (myReshape);
+    GLUT::ReshapeFunc(myReshape);
     GLUT::DisplayFunc(display);
     GLUT::MainLoop();
diff -ru opengl-0.32c-orig/sample/varray.rb opengl-0.32c/sample/varray.rb
--- opengl-0.32c-orig/sample/varray.rb	Mon Dec 22 20:26:25 2003
+++ opengl-0.32c/sample/varray.rb	Mon Dec 22 20:57:04 2003
@@ -67,11 +67,11 @@
                        0.35, 0.35, 0.35,
                        0.5, 0.5, 0.5].pack("f*");
 
-   GL.EnableClientState (GL::VERTEX_ARRAY);
-   GL.EnableClientState (GL::COLOR_ARRAY);
+   GL.EnableClientState(GL::VERTEX_ARRAY);
+   GL.EnableClientState(GL::COLOR_ARRAY);
 
-   GL.VertexPointer (2, GL::INT, 0, $vertices);
-   GL.ColorPointer (3, GL::FLOAT, 0, $colors);
+   GL.VertexPointer(2, GL::INT, 0, $vertices);
+   GL.ColorPointer(3, GL::FLOAT, 0, $colors);
 end
 
 def  setupInterleave
@@ -83,38 +83,38 @@
        0.2, 1.0, 1.0, 300.0, 200.0, 0.0,
        0.2, 0.2, 1.0, 200.0, 100.0, 0.0].pack("f*");
    
-   GL.InterleavedArrays (GL::C3F_V3F, 0, $intertwined);
+   GL.InterleavedArrays(GL::C3F_V3F, 0, $intertwined);
 end
 
 def init
-   GL.ClearColor (0.0, 0.0, 0.0, 0.0);
-   GL.ShadeModel (GL::SMOOTH);
-   setupPointers ();
+   GL.ClearColor(0.0, 0.0, 0.0, 0.0);
+   GL.ShadeModel(GL::SMOOTH);
+   setupPointers();
 end
 
 display = proc {
-   GL.Clear (GL::COLOR_BUFFER_BIT);
+   GL.Clear(GL::COLOR_BUFFER_BIT);
 
    if ($derefMethod == DRAWARRAY) 
-      GL.DrawArrays (GL::TRIANGLES, 0, 6);
+      GL.DrawArrays(GL::TRIANGLES, 0, 6);
    elsif ($derefMethod == ARRAYELEMENT)
-      GL.Begin (GL::TRIANGLES);
-      GL.ArrayElement (2);
-      GL.ArrayElement (3);
-      GL.ArrayElement (5);
-      GL.End ();
+      GL.Begin(GL::TRIANGLES);
+      GL.ArrayElement(2);
+      GL.ArrayElement(3);
+      GL.ArrayElement(5);
+      GL.End();
    elsif ($derefMethod == DRAWELEMENTS)
       $indices = [0, 1, 3, 4].pack("I*")
-      GL.DrawElements (GL::POLYGON, 4, GL::UNSIGNED_INT, $indices);
+      GL.DrawElements(GL::POLYGON, 4, GL::UNSIGNED_INT, $indices);
    end
-   GL.Flush ();
+   GL.Flush();
 }
 
 reshape = proc {|w, h|
-   GL.Viewport (0, 0, w, h);
-   GL.MatrixMode (GL::PROJECTION);
-   GL.LoadIdentity ();
-   GLU.Ortho2D (0.0, w, 0.0, h);
+   GL.Viewport(0, 0, w, h);
+   GL.MatrixMode(GL::PROJECTION);
+   GL.LoadIdentity();
+   GLU.Ortho2D(0.0, w, 0.0, h);
 }
 
 #/* ARGSUSED2 */
@@ -154,13 +154,13 @@
 }
 
    GLUT.Init();
-   GLUT.InitDisplayMode (GLUT::SINGLE | GLUT::RGB);
-   GLUT.InitWindowSize (350, 350); 
-   GLUT.InitWindowPosition (100, 100);
+   GLUT.InitDisplayMode(GLUT::SINGLE | GLUT::RGB);
+   GLUT.InitWindowSize(350, 350); 
+   GLUT.InitWindowPosition(100, 100);
    GLUT.CreateWindow()
-   init ();
+   init();
    GLUT.DisplayFunc(display); 
    GLUT.ReshapeFunc(reshape);
    GLUT.MouseFunc(mouse);
-   GLUT.KeyboardFunc (keyboard);
+   GLUT.KeyboardFunc(keyboard);
    GLUT.MainLoop();
