Copied JOGL_2_SANDBOX r350 on to trunk; JOGL_2_SANDBOX branch is now closed

git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/../svn-server-sync/jogl-demos/trunk@352 3298f667-5e0e-4b4a-8ed4-a3559d26a5f4

4 files changed, 833 insertions, 0 deletions

diff --git a/src/demos/misc/GLCapsTableDemo.java b/src/demos/misc/GLCapsTableDemo.java
new file mode 100755
index 0000000..bc77c0b
--- /dev/null
+++ b/src/demos/misc/GLCapsTableDemo.java
@@ -0,0 +1,341 @@
+package demos.misc;
+
+
+import javax.swing.border.TitledBorder;
+import javax.swing.table.TableColumn;
+
+import demos.gears.Gears;
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import java.awt.Toolkit;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.util.ArrayList;
+import javax.media.nativewindow.Capabilities;
+import javax.media.opengl.DefaultGLCapabilitiesChooser;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.awt.GLCanvas;
+import com.sun.opengl.util.FPSAnimator;
+import javax.swing.BorderFactory;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTable;
+
+/*******************************************************************************
+ * @file GLCapsTableDemo.java
+ * @desc Demonstrate use of GLCapabilitiesChooser and DefaultGLCapabilities.
+ *       Demo tabulates the available capabilities array and put the data into a
+ *       table. Pressing respawn button displays a canvas created with the
+ *       currently selected index corresponding to the available array. There
+ *       are two canvas to respawn: left or right.<br>
+ *       TODO: if the number of samples > 0, setSampleBuffer(true) and run an
+ *       antialiased renderer?;<br>
+ *       TODO: if pbuffer is available, enable Float, RTT, RTTRec and create a
+ *       pbuffer for eacH?<br>
+ *       TODO: spawn using a diff renderer option(such as ones from demo
+ *       package) <br>
+ * @version Jan 22, 2006 - GLCapsTableDemo.java created at 7:17:31 PM
+ * @platform ATI X600SE/XP Tablet SP2/JDK5/Eclipse
+ * @author Kiet Le
+ * @legal (c) 2006 Kiet Le. Released under BSD licence.
+ ******************************************************************************/
+public class GLCapsTableDemo
+  extends JFrame
+  implements
+    GLCapabilitiesChooser
+{
+  private String[] colNames =
+  {"Pfd", "H/W", "DblBfr", "Stereo", // index, hwaccel, double, stereo
+   "CBits", "cR", "cG", "cB", "cA", // color bits
+   "ABits", "aR", "aG", "aB", "aA", // accum bits
+   "Z", "S", "AA|AAS", "PBuf(Float|RTT|RTTRec)"}; // depth, stencil, n
+  // samples, pbuffer
+  private ArrayList/*<GLCapabilities>*/ available = new ArrayList/*<GLCapabilities>*/();
+  private ArrayList/*<Integer>*/ indices = new ArrayList/*<Integer>*/();
+  private Object[][] data;
+  private JTable capsTable;
+  private int desiredCapIndex; // pfd index
+  private int selected = desiredCapIndex;
+  protected JPanel pane, pane2;
+  private boolean updateLR;// leftright
+  private DefaultGLCapabilitiesChooser choiceExaminer = //
+    new DefaultGLCapabilitiesChooser()
+    {
+      public int chooseCapabilities(Capabilities _desired,
+                                    Capabilities[] _available,
+                                    int windowSystemRecommendedChoice)
+      {
+        GLCapabilities desired = (GLCapabilities) _desired;
+        GLCapabilities[] available = (GLCapabilities[]) _available;
+        if ( available != null )
+          for (int i = 0; i < available.length; i++) {
+            GLCapabilities c = available[i];
+            if (c != null) {
+              GLCapsTableDemo.this.available.add((GLCapabilities) c.clone());
+              GLCapsTableDemo.this.indices.add(new Integer(i));
+            }
+          }
+        desiredCapIndex = super.chooseCapabilities(desired, available,
+                                                   windowSystemRecommendedChoice);
+        System.out.println("valid" + desiredCapIndex);
+        capsTable = GLCapsTableDemo.this
+          .tabulateTable(GLCapsTableDemo.this.available, GLCapsTableDemo.this.indices);
+        JScrollPane scroller = //
+          new JScrollPane(capsTable, JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
+                          JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+        GLCapsTableDemo.this.getContentPane().add(scroller);
+        pane.setBorder(BorderFactory
+                       .createTitledBorder(null, "" + desiredCapIndex, TitledBorder.TRAILING,
+                                           TitledBorder.DEFAULT_POSITION));
+        pane2.setBorder(BorderFactory
+                        .createTitledBorder(null, "" + desiredCapIndex, TitledBorder.LEADING,
+                                            TitledBorder.DEFAULT_POSITION));
+        GLCapsTableDemo.this.validate();// so table'll show up
+        System.out.println("valid");
+        return desiredCapIndex;
+      }
+    };
+  private GraphicsDevice device = GraphicsEnvironment
+    .getLocalGraphicsEnvironment().getDefaultScreenDevice();
+  private JSplitPane canvasPane;
+
+  private GLCanvas canvas;
+  private GLCanvas canvas2;
+  private Gears topRenderer = new Gears(), bottomRenderer = new Gears();
+  private FPSAnimator animator;
+  private Dimension defdim = new Dimension(512, 256);
+  private String visTip = "If no gears are visible, it may be that the "
+    + "current desktop color resolution doesn't match "
+    + "the GLCapabilities chosen. Check CBits column.";
+
+  /**
+	 
+  */
+  public GLCapsTableDemo()
+  {
+    super(GLCapsTableDemo.class.getName());
+    initComponents();
+  }
+
+  /**
+   * (non-Javadoc)
+   * 
+   * @see javax.media.opengl.GLCapabilitiesChooser#chooseCapabilities(javax.media.nativewindow.Capabilities,
+   *      javax.media.nativewindow.Capabilities[], int)
+   */
+  public int chooseCapabilities(Capabilities desired,
+                                Capabilities[] available,
+                                int windowSystemRecommendedChoice)
+  {
+    int row = capsTable.getSelectedRow();
+    if ( 0> row || row >= indices.size() ) return windowSystemRecommendedChoice;
+    int desiredCapIndex = ((Integer) indices.get(row)).intValue();
+    if ( updateLR )
+      {
+        pane.setBorder(BorderFactory
+                       .createTitledBorder(null, "" + desiredCapIndex,
+                                           TitledBorder.TRAILING,
+                                           TitledBorder.DEFAULT_POSITION));
+      }
+    else
+      {
+        pane2.setBorder(BorderFactory
+                        .createTitledBorder(null, "" + desiredCapIndex, TitledBorder.LEADING,
+                                            TitledBorder.DEFAULT_POSITION));
+      }
+    return desiredCapIndex;
+  }
+
+  public void run(final String[] args)
+  {
+    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+    Dimension d = Toolkit.getDefaultToolkit().getScreenSize();
+    setSize(new Dimension((int) (d.width * 0.75), (int) (d.height * 0.75)));
+    setLocationRelativeTo(null);
+    setVisible(true);
+    validate();
+    animator.start();
+  }//
+
+  /**
+   * @param args
+   */
+  public static void main(String[] args)
+  {
+    GLCapsTableDemo demo = new GLCapsTableDemo();
+    demo.run(args);
+  }
+
+  private void initComponents()
+  {
+    pane = new JPanel();
+    pane2 = new JPanel();
+
+    // Hack: use multisampled capabilities to pick up more detailed information on Windows
+    GLCapabilities multisampledCaps = new GLCapabilities(null);
+    multisampledCaps.setSampleBuffers(true);
+    canvas = new GLCanvas(multisampledCaps, choiceExaminer, null, device);
+
+    // initially start w/ 2 canvas of default caps
+    // canvas = new GLCanvas(null, choiceExaminer, null, device);
+    canvas.addGLEventListener(topRenderer);
+    canvas.setSize(defdim);
+    //    canvas.setPreferredSize(defdim);
+    //    canvas.setMaximumSize(defdim);
+    animator = new FPSAnimator(canvas, 30);
+    canvas2 = new GLCanvas(null, null, null, device);
+    canvas2.addGLEventListener(bottomRenderer);
+    canvas2.setSize(defdim);
+    //    canvas2.setPreferredSize(defdim);
+    //    canvas2.setMaximumSize(defdim);
+    animator.add(canvas2);
+    pane.add(canvas);
+    pane2.add(canvas2);
+    canvasPane = new JSplitPane();
+    canvasPane.setResizeWeight(0.5);// 50-50 division
+    canvasPane.setOrientation(JSplitPane.HORIZONTAL_SPLIT);
+    canvasPane.setLeftComponent(pane);
+    canvasPane.setRightComponent(pane2);
+    getContentPane().add(canvasPane, BorderLayout.SOUTH);
+    getContentPane().add(buildControls(), BorderLayout.NORTH);
+  }
+
+  private JTable tabulateTable(ArrayList/*<GLCapabilities>*/ capabilities,
+                               ArrayList/*<Integer>*/ indices)
+  {
+    capabilities.trimToSize();
+    data = new Object[capabilities.size()][colNames.length];
+    String t = "T", f = "F";
+    for (int pfd = 0; pfd < capabilities.size(); pfd++)
+      {
+        data[ pfd ][ 0 ] = indices.get(pfd);
+        GLCapabilities cap = (GLCapabilities) capabilities.get(pfd);
+        data[ pfd ][ 1 ] = "" + (cap.getHardwareAccelerated() ? f : f);
+        data[ pfd ][ 2 ] = "" + (cap.getDoubleBuffered() ? t : f);
+        data[ pfd ][ 3 ] = "" + (cap.getStereo() ? t : f);
+        int r = cap.getRedBits(), // 
+          g = cap.getGreenBits(), //
+          b = cap.getBlueBits(), //
+          a = cap.getAlphaBits();
+        data[ pfd ][ 4 ] = "" + (r + g + b + a);
+        data[ pfd ][ 5 ] = new Integer(r);
+        data[ pfd ][ 6 ] = new Integer(g);
+        data[ pfd ][ 7 ] = new Integer(b);
+        data[ pfd ][ 8 ] = new Integer(a);
+        r = cap.getAccumRedBits();
+        g = cap.getAccumGreenBits();
+        b = cap.getAccumBlueBits();
+        a = cap.getAccumAlphaBits();
+        data[ pfd ][ 9 ] = "" + (r + g + b + a);
+        data[ pfd ][ 10 ] = new Integer(r);
+        data[ pfd ][ 11 ] = new Integer(g);
+        data[ pfd ][ 12 ] = new Integer(b);
+        data[ pfd ][ 13 ] = new Integer(a);
+        //
+        data[ pfd ][ 14 ] = "" + cap.getDepthBits();
+        data[ pfd ][ 15 ] = "" + cap.getStencilBits();
+        data[ pfd ][ 16 ] = "" + (cap.getSampleBuffers() ? t : f) + " | "
+          + cap.getNumSamples();
+        // concat p buffer nfo
+        String pbuf = (cap.getPbufferFloatingPointBuffers() ? "T |" : "F |");
+        pbuf += (cap.getPbufferRenderToTexture() ? "T | " : "F | ");
+        pbuf += (cap.getPbufferRenderToTextureRectangle() ? t : f);
+        data[ pfd ][ 17 ] = pbuf;
+      }
+    JTable table = new JTable(data, colNames) {
+        public boolean isCellEditable(int rowIndex, int colIndex) {
+          return false;
+        }
+      };
+    //    table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+    table.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
+    TableColumn column = null;
+    for (int i = 0; i < colNames.length; i++)
+      {
+        column = table.getColumnModel().getColumn(i);
+        if ( i == (colNames.length - 1) )
+          {
+            column.setPreferredWidth(100); // pbuffer column is bigger
+          }
+        else column.setPreferredWidth(7);
+      }
+    table.setDoubleBuffered(true);
+    return table;
+  }
+
+  private JPanel buildControls()
+  {
+    JPanel controls = new JPanel();
+    final JButton spawn = new JButton("Respawn Left");
+    final JButton spawn2 = new JButton("Respawn Right");
+    ActionListener recap = new ActionListener()
+      {
+        public void actionPerformed(final ActionEvent act)
+        {
+          animator.stop();
+          if ( act.getSource() == spawn )
+            {
+              updateLR = true;// left
+              animator.remove(canvas);
+              pane.remove(canvas);
+              canvas = newCanvas(true, true);// get new canvas w/ selected index
+              pane.add(canvas);
+              animator.add(canvas);
+            }
+          else
+            {
+              updateLR = false;
+              animator.remove(canvas2);
+              pane2.remove(canvas2);
+              canvas2 = newCanvas(true, false);
+              pane2.add(canvas2);
+              animator.add(canvas2);
+            }
+          new Thread()
+          {
+            public void run()
+            {
+              animator.start();
+            }
+          }.start();
+          GLCapsTableDemo.this.validate();
+        }
+      };
+    spawn.setToolTipText(visTip);
+    spawn.addActionListener(recap);
+    spawn2.addActionListener(recap);
+    //
+    controls.add(spawn);
+    controls.add(spawn2);
+    return controls;
+  }
+
+  private GLCanvas newCanvas(boolean mycap, boolean top)
+  {
+    GLCanvas surface = null;
+    if ( !mycap ) surface = new GLCanvas(null, choiceExaminer, null, device);
+    else surface = new GLCanvas(null, this, null, device);
+    if ( top ) surface.addGLEventListener(topRenderer);
+    else surface.addGLEventListener(bottomRenderer);
+    surface.setSize(defdim);// otherwise, no show; mixin' light-heavy containers
+    //  surface.setMinimumSize(defdim);
+    return surface;
+  }
+
+  private void exitRunner()
+  {
+    new Thread()
+    {
+      public void run()
+      {
+        animator.stop();
+      }
+    };
+  }
+}//
diff --git a/src/demos/misc/Picking.java b/src/demos/misc/Picking.java
new file mode 100755
index 0000000..fde486c
--- /dev/null
+++ b/src/demos/misc/Picking.java
@@ -0,0 +1,275 @@
+package demos.misc;
+
+//=================================================================================
+// Picking 0.2                                                       (Thomas Bladh)
+//=================================================================================
+// A simple picking example using java/jogl. This is far from a complete solution 
+// but it should give you an idea of how to include picking in your assigment 
+// solutions.
+//
+// Notes: * Based on example 13-3 (p 542) in the "OpenGL Programming Guide"
+//        * This version should handle overlapping objects correctly.
+//---------------------------------------------------------------------------------
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.Canvas.*;
+import java.nio.*;
+import javax.media.opengl.*;
+import javax.media.opengl.awt.GLCanvas;
+import javax.media.opengl.glu.*;
+import com.sun.opengl.util.Animator;
+import com.sun.opengl.util.BufferUtil;
+
+public class Picking
+{
+  public static void main(String[] args) 
+  {
+    new Picking();
+  }
+  	
+  Picking()
+  {
+    Frame frame = new Frame("Picking Example");
+    GLCapabilities capabilities = new GLCapabilities(null);
+    GLDrawableFactory factory = GLDrawableFactory.getFactory(capabilities.getGLProfile());
+    GLCanvas drawable = new GLCanvas(capabilities);
+    final Renderer renderer = new Renderer();
+    drawable.addGLEventListener(renderer);
+    drawable.addMouseListener(renderer);
+    drawable.addMouseMotionListener(renderer);
+    frame.add(drawable);
+    frame.setSize(400, 400);
+    final Animator animator = new Animator(drawable);
+    frame.addWindowListener(new WindowAdapter()
+      {
+        public void windowClosing(WindowEvent e) 
+        {
+          animator.stop();
+          System.exit(0);
+        }
+      });
+    frame.setVisible(true);
+    animator.start();	
+  }
+
+  static class Renderer implements GLEventListener, MouseListener, MouseMotionListener 
+  {
+    static final int NOTHING = 0, UPDATE = 1, SELECT = 2;
+    int cmd = UPDATE;
+    int mouse_x, mouse_y;
+	
+    private GLU glu = new GLU();
+    private GLAutoDrawable gldrawable;
+		
+    public void init(GLAutoDrawable drawable) 
+    {
+      GL2 gl = drawable.getGL().getGL2();
+      this.gldrawable = drawable;
+      gl.glEnable(GL2.GL_CULL_FACE);
+      gl.glEnable(GL2.GL_DEPTH_TEST);
+      gl.glEnable(GL2.GL_NORMALIZE);
+      gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    }
+    	
+    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) 
+    {
+      GL2 gl = drawable.getGL().getGL2();
+      float h = (float) height / (float) width;
+      gl.glViewport(0, 0, width, height);
+      gl.glMatrixMode(GL2.GL_PROJECTION);
+      gl.glLoadIdentity();
+      glu.gluOrtho2D(0.0f,1.0f,0.0f,1.0f);
+    }
+
+    public void dispose(GLAutoDrawable drawable) {
+    }
+
+    public void display(GLAutoDrawable drawable) 
+    {
+      GL2 gl = drawable.getGL().getGL2();
+      switch(cmd)
+        {
+        case UPDATE:
+          drawScene(gl);
+          break;
+        case SELECT:
+          int buffsize = 512;
+          double x = (double) mouse_x, y = (double) mouse_y;
+          int[] viewPort = new int[4];
+          IntBuffer selectBuffer = BufferUtil.newIntBuffer(buffsize);
+          int hits = 0;
+          gl.glGetIntegerv(GL2.GL_VIEWPORT, viewPort, 0);
+          gl.glSelectBuffer(buffsize, selectBuffer);
+          gl.glRenderMode(GL2.GL_SELECT);
+          gl.glInitNames();
+          gl.glMatrixMode(GL2.GL_PROJECTION);
+          gl.glPushMatrix();
+          gl.glLoadIdentity();
+          glu.gluPickMatrix(x, (double) viewPort[3] - y, 5.0d, 5.0d, viewPort, 0);
+          glu.gluOrtho2D(0.0d, 1.0d, 0.0d, 1.0d);
+          drawScene(gl);
+          gl.glMatrixMode(GL2.GL_PROJECTION);
+          gl.glPopMatrix();
+          gl.glFlush();
+          hits = gl.glRenderMode(GL2.GL_RENDER);
+          processHits(hits, selectBuffer);
+          cmd = UPDATE;
+          break;
+        }
+    }
+
+    public void processHits(int hits, IntBuffer buffer)
+    {
+      System.out.println("---------------------------------");
+      System.out.println(" HITS: " + hits);
+      int offset = 0;
+      int names;
+      float z1, z2;
+      for (int i=0;i<hits;i++)
+        {
+          System.out.println("- - - - - - - - - - - -");
+          System.out.println(" hit: " + (i + 1));
+          names = buffer.get(offset); offset++;
+          z1 = (float) buffer.get(offset) / 0x7fffffff; offset++;
+          z2 = (float) buffer.get(offset) / 0x7fffffff; offset++;
+          System.out.println(" number of names: " + names);
+          System.out.println(" z1: " + z1);
+          System.out.println(" z2: " + z2);
+          System.out.println(" names: ");
+
+          for (int j=0;j<names;j++)
+            {
+              System.out.print("       " + buffer.get(offset)); 
+              if (j==(names-1))
+                System.out.println("<-");
+              else
+                System.out.println();
+              offset++;
+            }
+          System.out.println("- - - - - - - - - - - -");
+        }
+      System.out.println("---------------------------------");
+    }
+		
+    public int viewPortWidth(GL2 gl)
+    {
+      int[] viewPort = new int[4];
+      gl.glGetIntegerv(GL2.GL_VIEWPORT, viewPort, 0);
+      return viewPort[2];
+    }
+
+    public int viewPortHeight(GL2 gl)
+    {
+      int[] viewPort = new int[4];
+      gl.glGetIntegerv(GL2.GL_VIEWPORT, viewPort, 0);
+      return viewPort[3];
+    }
+
+    public void drawScene(GL2 gl)
+    {
+      gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
+
+      // Colors
+      float red[] =   {1.0f,0.0f,0.0f,1.0f};
+      float green[] = {0.0f,1.0f,0.0f,1.0f};
+      float blue[] =  {0.0f,0.0f,1.0f,1.0f};
+	
+      // Red rectangle
+      GLRectangleEntity r1 = new GLRectangleEntity(gl, glu);
+      r1.x = 0.15f;
+      r1.y = 0.25f;
+      r1.z = 0.75f;
+      r1.w = 0.4f;
+      r1.h = 0.4f;
+      r1.c = red;
+      r1.id = 10;
+      r1.draw();
+
+      // Green rectangle
+      GLRectangleEntity r2 = new GLRectangleEntity(gl, glu);
+      r2.x = 0.35f;
+      r2.y = 0.45f;
+      r2.z = 0.5f;
+      r2.w = 0.4f;
+      r2.h = 0.4f;
+      r2.c = green;
+      r2.id = 20;
+      r2.draw();
+
+      // Blue rectangle
+      GLRectangleEntity r3 = new GLRectangleEntity(gl, glu);
+      r3.x = 0.45f;
+      r3.y = 0.15f;
+      r3.z = 0.25f;
+      r3.w = 0.4f;
+      r3.h = 0.4f;
+      r3.c = blue;
+      r3.id = 30;
+      r3.draw();
+
+      gl.glFlush();
+    }
+
+    public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
+				
+    public void mousePressed(MouseEvent e) 
+    {
+      cmd = SELECT;
+      mouse_x = e.getX();
+      mouse_y = e.getY();
+    }
+
+    public void mouseEntered(MouseEvent e) {}
+    public void mouseExited(MouseEvent e) {}
+    public void mouseReleased(MouseEvent e) {}
+    public void mouseClicked(MouseEvent e) {}
+    public void mouseDragged(MouseEvent e) {}
+    public void mouseMoved(MouseEvent e) {}
+    
+    public abstract class GLEntity
+    {
+      float x, y, z;
+      float[] c;
+      int id = 0;
+      boolean outline = false;
+      GL2 gl;
+      GLU glu;
+      public GLEntity(GL2 gl, GLU glu)
+      {
+        this.gl = gl;
+        this.glu = glu;
+      }
+      public void draw()
+      {
+        gl.glPushName(id);
+        _draw();
+      }
+      public abstract void _draw();
+    }
+
+    public class GLRectangleEntity extends GLEntity
+    {
+      float w = 0.1f;
+      float h = 0.1f;
+      public GLRectangleEntity(GL2 gl, GLU glu)
+      {
+        super(gl, glu);
+      }
+      public void _draw()
+      {
+        if (outline)
+          gl.glPolygonMode(GL2.GL_FRONT, GL2.GL_LINE);
+        else
+          gl.glPolygonMode(GL2.GL_FRONT, GL2.GL_FILL);
+
+        gl.glColor4fv(c, 0);
+        gl.glBegin(GL2.GL_POLYGON);
+        gl.glVertex3f(x, y, z);
+        gl.glVertex3f(x + w, y, z);
+        gl.glVertex3f(x + w, y + h, z);
+        gl.glVertex3f(x, y + h, z);
+        gl.glEnd();
+      }			
+    }
+  }
+}
diff --git a/src/demos/misc/TiledRendering.java b/src/demos/misc/TiledRendering.java
new file mode 100755
index 0000000..a5034fa
--- /dev/null
+++ b/src/demos/misc/TiledRendering.java
@@ -0,0 +1,159 @@
+package demos.misc;
+
+import com.sun.opengl.util.FileUtil;
+import com.sun.opengl.util.TGAWriter;
+import com.sun.opengl.util.awt.ImageUtil;
+import com.sun.opengl.util.gl2.TileRenderer;
+import demos.gears.Gears;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferByte;
+import java.io.File;
+import java.io.IOException;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import javax.imageio.ImageIO;
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES1;
+import javax.media.opengl.GL2;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLDrawableFactory;
+import javax.media.opengl.GLPbuffer;
+
+/** Demonstrates the TileRenderer class by rendering a large version
+    of the Gears demo to the specified file. */
+
+public class TiledRendering {
+
+  public static void main(String[] args) throws IOException {
+      
+    if (args.length != 1) {
+      System.out.println("Usage: java TiledRendering [output file name]");
+      System.out.println("Writes output (a large version of the Gears demo) to");
+      System.out.println("the specified file, using either ImageIO or the fast TGA writer");
+      System.out.println("depending on the file extension.");
+      System.exit(1);
+    }
+
+    String filename = args[0];
+    File file = new File(filename);
+
+    GLCapabilities caps = new GLCapabilities(null);
+    caps.setDoubleBuffered(false);
+
+    if (!GLDrawableFactory.getFactory(caps.getGLProfile()).canCreateGLPbuffer()) {
+      System.out.println("Demo requires pbuffer support");
+      System.exit(1);
+    }
+
+    // Use a pbuffer for rendering
+    GLPbuffer pbuffer = GLDrawableFactory.getFactory(caps.getGLProfile()).createGLPbuffer(caps, null,
+                                                                       256, 256,
+                                                                       null);
+    
+    // Fix the image size for now
+    int tileWidth = 256;
+    int tileHeight = 256;
+    int imageWidth = tileWidth * 16;
+    int imageHeight = tileHeight * 12;
+    
+    // Figure out the file format
+    TGAWriter tga = null;
+    BufferedImage img = null;
+    Buffer buf = null;
+    
+    if (filename.endsWith(".tga")) {
+      tga = new TGAWriter();
+      tga.open(file,
+               imageWidth,
+               imageHeight,
+               false);
+      buf = tga.getImageData();
+    } else {
+      img = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_3BYTE_BGR);
+      buf = ByteBuffer.wrap(((DataBufferByte) img.getRaster().getDataBuffer()).getData());
+    }
+
+    // Initialize the tile rendering library
+    TileRenderer renderer = new TileRenderer();
+    renderer.setTileSize(tileWidth, tileHeight, 0);
+    renderer.setImageSize(imageWidth, imageHeight);
+    renderer.setImageBuffer(GL2.GL_BGR, GL.GL_UNSIGNED_BYTE, buf);
+    renderer.trPerspective(20.0f, (float) imageWidth / (float) imageHeight, 5.0f, 60.0f);
+
+    GLContext context = pbuffer.getContext();
+    if (context.makeCurrent() == GLContext.CONTEXT_NOT_CURRENT) {
+      System.out.println("Error making pbuffer's context current");
+      System.exit(1);
+    }
+    
+    GL2 gl = pbuffer.getGL().getGL2();
+    gl.glMatrixMode(GL2ES1.GL_MODELVIEW);
+    gl.glLoadIdentity();
+    gl.glTranslatef(0.0f, 0.0f, -40.0f);
+    // Tile renderer will set up projection matrix    
+
+    do {
+      renderer.beginTile(gl);
+      drawGears(gl);
+    } while (renderer.endTile(gl));
+
+    context.release();
+
+    // Close things up and/or write image using ImageIO
+    if (tga != null) {
+      tga.close();
+    } else {
+      ImageUtil.flipImageVertically(img);
+      if (!ImageIO.write(img, FileUtil.getFileSuffix(file), file)) {
+        System.err.println("Error writing file using ImageIO (unsupported file format?)");
+      }
+    }
+  }
+
+  private static void drawGears(GL2 gl) {
+    float view_rotx = 20.0f, view_roty = 30.0f, view_rotz = 0.0f;
+    float angle = 0.0f;
+    float pos[] = { 5.0f, 5.0f, 10.0f, 0.0f };
+    float red[] = { 0.8f, 0.1f, 0.0f, 1.0f };
+    float green[] = { 0.0f, 0.8f, 0.2f, 1.0f };
+    float blue[] = { 0.2f, 0.2f, 1.0f, 1.0f };
+
+    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+
+    gl.glLightfv(GL2ES1.GL_LIGHT0, GL2ES1.GL_POSITION, pos, 0);
+    gl.glEnable(GL.GL_CULL_FACE);
+    gl.glEnable(GL2ES1.GL_LIGHTING);
+    gl.glEnable(GL2ES1.GL_LIGHT0);
+    gl.glEnable(GL.GL_DEPTH_TEST);
+    gl.glEnable(GL2ES1.GL_NORMALIZE);
+
+    gl.glPushMatrix();
+    gl.glRotatef(view_rotx, 1.0f, 0.0f, 0.0f);
+    gl.glRotatef(view_roty, 0.0f, 1.0f, 0.0f);
+    gl.glRotatef(view_rotz, 0.0f, 0.0f, 1.0f);
+            
+    gl.glPushMatrix();
+    gl.glTranslatef(-3.0f, -2.0f, 0.0f);
+    gl.glRotatef(angle, 0.0f, 0.0f, 1.0f);
+    gl.glMaterialfv(GL.GL_FRONT, GL2ES1.GL_AMBIENT_AND_DIFFUSE, red, 0);
+    Gears.gear(gl, 1.0f, 4.0f, 1.0f, 20, 0.7f);
+    gl.glPopMatrix();
+            
+    gl.glPushMatrix();
+    gl.glTranslatef(3.1f, -2.0f, 0.0f);
+    gl.glRotatef(-2.0f * angle - 9.0f, 0.0f, 0.0f, 1.0f);
+    gl.glMaterialfv(GL.GL_FRONT, GL2ES1.GL_AMBIENT_AND_DIFFUSE, green, 0);
+    Gears.gear(gl, 0.5f, 2.0f, 2.0f, 10, 0.7f);
+    gl.glPopMatrix();
+            
+    gl.glPushMatrix();
+    gl.glTranslatef(-3.1f, 4.2f, 0.0f);
+    gl.glRotatef(-2.0f * angle - 25.0f, 0.0f, 0.0f, 1.0f);
+    gl.glMaterialfv(GL.GL_FRONT, GL2ES1.GL_AMBIENT_AND_DIFFUSE, blue, 0);
+    Gears.gear(gl, 1.3f, 2.0f, 0.5f, 10, 0.7f);
+    gl.glPopMatrix();
+            
+    gl.glPopMatrix();
+  }
+}
diff --git a/src/demos/misc/VersionInfo.java b/src/demos/misc/VersionInfo.java
new file mode 100644
index 0000000..589d899
--- /dev/null
+++ b/src/demos/misc/VersionInfo.java
@@ -0,0 +1,58 @@
+
+package demos.misc;
+
+/**
+ * VersionInfo.java <BR>
+ * author: Travis Bryson <P>
+ *
+ * This program returns the version and implementation information for the Java 
+ * Bindings for OpenGL (R) implementation found in the CLASSPATH.  This information
+ * is also found in the manifest for jogl.jar, and this program uses the 
+ * java.lang.Package class to retrieve it programatically.  
+**/
+
+public class VersionInfo {
+    public VersionInfo() {
+	ClassLoader classLoader = getClass().getClassLoader();
+	pkgInfo(classLoader, "javax.media.opengl", "GL");
+    }
+
+    static void pkgInfo(ClassLoader classLoader,
+			String pkgName,
+			String className) {
+
+	try {
+	    classLoader.loadClass(pkgName + "." + className);
+
+	    Package p = Package.getPackage(pkgName);
+	    if (p == null) {
+		System.out.println("WARNING: Package.getPackage(" +
+				   pkgName +
+				   ") is null");
+	    }
+	    else {
+		System.out.println(p);
+		System.out.println("Specification Title = " +
+				   p.getSpecificationTitle());
+		System.out.println("Specification Vendor = " +
+				   p.getSpecificationVendor());
+		System.out.println("Specification Version = " +
+				   p.getSpecificationVersion());
+
+		System.out.println("Implementation Vendor = " +
+				   p.getImplementationVendor());
+		System.out.println("Implementation Version = " +
+				   p.getImplementationVersion());
+	    }
+	}
+	catch (ClassNotFoundException e) {
+	    System.out.println("Unable to load " + pkgName);
+	}
+
+	System.out.println();
+    }
+
+    public static void main(String[] args) {
+	new VersionInfo();
+    }
+}