Deleted obsolete source code in preparation for copying JOGL_2_SANDBOX

on to trunk


git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@1958 232f8b59-042b-4e1e-8c03-345bb8c30851

3 files changed, 0 insertions, 2840 deletions

diff --git a/src/classes/com/sun/opengl/util/j2d/Overlay.java b/src/classes/com/sun/opengl/util/j2d/Overlay.java
deleted file mode 100755
index 6b7ac4b9b..000000000
--- a/src/classes/com/sun/opengl/util/j2d/Overlay.java
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- * - Redistribution of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * 
- * - Redistribution 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 Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- * 
- * This software is provided "AS IS," without a warranty of any kind. ALL
- * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
- * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
- * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
- * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
- * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
- * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
- * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
- * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
- * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- * 
- * You acknowledge that this software is not designed or intended for use
- * in the design, construction, operation or maintenance of any nuclear
- * facility.
- * 
- * Sun gratefully acknowledges that this software was originally authored
- * and developed by Kenneth Bradley Russell and Christopher John Kline.
- */
-
-package com.sun.opengl.util.j2d;
-
-import java.awt.Graphics2D;
-
-import javax.media.opengl.*;
-import com.sun.opengl.util.texture.*;
-
-/** Provides a Java 2D overlay on top of an arbitrary GLDrawable,
-    making it easier to do things like draw text and images on top of
-    an OpenGL scene while still maintaining reasonably good
-    efficiency. */
-
-public class Overlay {
-  private GLDrawable drawable;
-  private TextureRenderer renderer;
-  private boolean contentsLost;
-
-  /** Creates a new Java 2D overlay on top of the specified
-      GLDrawable. */
-  public Overlay(GLDrawable drawable) {
-    this.drawable = drawable;
-  }
-
-  /** Creates a {@link java.awt.Graphics2D Graphics2D} instance for
-      rendering into the overlay. The returned object should be
-      disposed of using the normal {@link java.awt.Graphics#dispose()
-      Graphics.dispose()} method once it is no longer being used.
-
-      @return a new {@link java.awt.Graphics2D Graphics2D} object for
-        rendering into the backing store of this renderer
-  */
-  public Graphics2D createGraphics() {
-    // Validate the size of the renderer against the current size of
-    // the drawable
-    validateRenderer();
-    return renderer.createGraphics();
-  }
-
-  /** Indicates whether the Java 2D contents of the overlay were lost
-      since the last time {@link #createGraphics} was called. This
-      method should be called immediately after calling {@link
-      #createGraphics} to see whether the entire contents of the
-      overlay need to be redrawn or just the region the application is
-      interested in updating.
-
-      @return whether the contents of the overlay were lost since the
-        last render
-  */
-  public boolean contentsLost() {
-    return contentsLost;
-  }
-
-  /** Marks the given region of the overlay as dirty. This region, and
-      any previously set dirty regions, will be automatically
-      synchronized with the underlying Texture during the next {@link
-      #draw draw} or {@link #drawAll drawAll} operation, at which
-      point the dirty region will be cleared. It is not necessary for
-      an OpenGL context to be current when this method is called.
-
-      @param x the x coordinate (in Java 2D coordinates -- relative to
-        upper left) of the region to update
-      @param y the y coordinate (in Java 2D coordinates -- relative to
-        upper left) of the region to update
-      @param width the width of the region to update
-      @param height the height of the region to update
-
-      @throws GLException If an OpenGL context is not current when this method is called */
-  public void markDirty(int x, int y, int width, int height) {
-    renderer.markDirty(x, y, width, height);
-  }
-
-  /** Draws the entire contents of the overlay on top of the OpenGL
-      drawable. This is a convenience method which encapsulates all
-      portions of the rendering process; if this method is used,
-      {@link #beginRendering}, {@link #endRendering}, etc. should not
-      be used. This method should be called while the OpenGL context
-      for the drawable is current, and after your OpenGL scene has
-      been rendered.
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void drawAll() throws GLException {
-    beginRendering();
-    draw(0, 0, drawable.getWidth(), drawable.getHeight());
-    endRendering();
-  }
-
-  /** Begins the OpenGL rendering process for the overlay. This is
-      separated out so advanced applications can render independent
-      pieces of the overlay to different portions of the drawable.
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void beginRendering() throws GLException {
-    renderer.beginOrthoRendering(drawable.getWidth(), drawable.getHeight());
-  }
-
-  /** Ends the OpenGL rendering process for the overlay. This is
-      separated out so advanced applications can render independent
-      pieces of the overlay to different portions of the drawable.
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void endRendering() throws GLException {
-    renderer.endOrthoRendering();
-  }
-
-  /** Draws the specified sub-rectangle of the overlay on top of the
-      OpenGL drawable. {@link #beginRendering} and {@link
-      #endRendering} must be used in conjunction with this method to
-      achieve proper rendering results. This method should be called
-      while the OpenGL context for the drawable is current, and after
-      your OpenGL scene has been rendered.
-
-      @param x the lower-left x coordinate (relative to the lower left
-        of the overlay) of the rectangle to draw
-      @param y the lower-left y coordinate (relative to the lower left
-        of the overlay) of the rectangle to draw
-      @param width the width of the rectangle to draw
-      @param height the height of the rectangle to draw
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void draw(int x, int y, int width, int height) throws GLException {
-    draw(x, y, x, y, width, height);
-  }
-
-  /** Draws the specified sub-rectangle of the overlay at the
-      specified x and y coordinate on top of the OpenGL drawable.
-      {@link #beginRendering} and {@link #endRendering} must be used
-      in conjunction with this method to achieve proper rendering
-      results. This method should be called while the OpenGL context
-      for the drawable is current, and after your OpenGL scene has
-      been rendered.
-
-      @param screenx the on-screen x coordinate at which to draw the rectangle
-      @param screeny the on-screen y coordinate (relative to lower left) at
-        which to draw the rectangle
-      @param overlayx the x coordinate of the pixel in the overlay of
-        the lower left portion of the rectangle to draw
-      @param overlayy the y coordinate of the pixel in the overlay
-        (relative to lower left) of the lower left portion of the
-        rectangle to draw
-      @param width the width of the rectangle to draw
-      @param height the height of the rectangle to draw
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void draw(int screenx, int screeny,
-                   int overlayx, int overlayy,
-                   int width, int height) throws GLException {
-    renderer.drawOrthoRect(screenx, screeny,
-                           overlayx, overlayy,
-                           width, height);
-  }
-
-  //----------------------------------------------------------------------
-  // Internals only below this point
-  //
-
-  private void validateRenderer() {
-    if (renderer == null) {
-      renderer = new TextureRenderer(drawable.getWidth(),
-                                     drawable.getHeight(),
-                                     true);
-      contentsLost = true;
-    } else if (renderer.getWidth() != drawable.getWidth() ||
-               renderer.getHeight() != drawable.getHeight()) {
-      renderer.setSize(drawable.getWidth(), drawable.getHeight());
-      contentsLost = true;
-    } else {
-      contentsLost = false;
-    }
-  }
-}
diff --git a/src/classes/com/sun/opengl/util/j2d/TextRenderer.java b/src/classes/com/sun/opengl/util/j2d/TextRenderer.java
deleted file mode 100755
index c8493affa..000000000
--- a/src/classes/com/sun/opengl/util/j2d/TextRenderer.java
+++ /dev/null
@@ -1,1931 +0,0 @@
-/*
- * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- * - Redistribution of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- *
- * - Redistribution 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 Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * This software is provided "AS IS," without a warranty of any kind. ALL
- * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
- * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
- * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
- * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
- * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
- * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
- * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
- * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
- * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- *
- * You acknowledge that this software is not designed or intended for use
- * in the design, construction, operation or maintenance of any nuclear
- * facility.
- *
- * Sun gratefully acknowledges that this software was originally authored
- * and developed by Kenneth Bradley Russell and Christopher John Kline.
- */
-package com.sun.opengl.util.j2d;
-
-import com.sun.opengl.impl.*;
-import com.sun.opengl.impl.packrect.*;
-import com.sun.opengl.util.*;
-import com.sun.opengl.util.texture.*;
-
-import java.awt.AlphaComposite;
-import java.awt.Color;
-import java.awt.Composite;
-
-// For debugging purposes
-import java.awt.EventQueue;
-import java.awt.Font;
-import java.awt.Frame;
-import java.awt.Graphics2D;
-import java.awt.Image;
-import java.awt.Point;
-import java.awt.RenderingHints;
-import java.awt.event.*;
-import java.awt.font.*;
-import java.awt.geom.*;
-
-import java.nio.*;
-
-import java.text.*;
-
-import java.util.*;
-
-import javax.media.opengl.*;
-import javax.media.opengl.glu.*;
-
-
-/** Renders bitmapped Java 2D text into an OpenGL window with high
-    performance, full Unicode support, and a simple API. Performs
-    appropriate caching of text rendering results in an OpenGL texture
-    internally to avoid repeated font rasterization. The caching is
-    completely automatic, does not require any user intervention, and
-    has no visible controls in the public API. <P>
-
-    Using the {@link TextRenderer TextRenderer} is simple. Add a
-    "<code>TextRenderer renderer;</code>" field to your {@link
-    javax.media.opengl.GLEventListener GLEventListener}. In your {@link
-    javax.media.opengl.GLEventListener#init init} method, add:
-
-    <PRE>
-    renderer = new TextRenderer(new Font("SansSerif", Font.BOLD, 36));
-    </PRE>
-
-    <P> In the {@link javax.media.opengl.GLEventListener#display display} method of your
-    {@link javax.media.opengl.GLEventListener GLEventListener}, add:
-    <PRE>
-    renderer.beginRendering(drawable.getWidth(), drawable.getHeight());
-    // optionally set the color
-    renderer.setColor(1.0f, 0.2f, 0.2f, 0.8f);
-    renderer.draw("Text to draw", xPosition, yPosition);
-    // ... more draw commands, color changes, etc.
-    renderer.endRendering();
-    </PRE>
-
-    Unless you are sharing textures and display lists between OpenGL
-    contexts, you do not need to call the {@link #dispose dispose}
-    method of the TextRenderer; the OpenGL resources it uses
-    internally will be cleaned up automatically when the OpenGL
-    context is destroyed. <P>
-
-    <b>Note</b> that the TextRenderer may cause the vertex and texture
-    coordinate array buffer bindings to change, or to be unbound. This
-    is important to note if you are using Vertex Buffer Objects (VBOs)
-    in your application. <P>
-
-    Internally, the renderer uses a rectangle packing algorithm to
-    pack both glyphs and full Strings' rendering results (which are
-    variable size) onto a larger OpenGL texture. The internal backing
-    store is maintained using a {@link
-    com.sun.opengl.util.j2d.TextureRenderer TextureRenderer}. A least
-    recently used (LRU) algorithm is used to discard previously
-    rendered strings; the specific algorithm is undefined, but is
-    currently implemented by flushing unused Strings' rendering
-    results every few hundred rendering cycles, where a rendering
-    cycle is defined as a pair of calls to {@link #beginRendering
-    beginRendering} / {@link #endRendering endRendering}.
-
-    @author John Burkey
-    @author Kenneth Russell
-*/
-public class TextRenderer {
-    private static final boolean DEBUG = Debug.debug("TextRenderer");
-
-    // These are occasionally useful for more in-depth debugging
-    private static final boolean DISABLE_GLYPH_CACHE = false;
-    private static final boolean DRAW_BBOXES = false;
-
-    static final int kSize = 256;
-
-    // Every certain number of render cycles, flush the strings which
-    // haven't been used recently
-    private static final int CYCLES_PER_FLUSH = 100;
-
-    // The amount of vertical dead space on the backing store before we
-    // force a compaction
-    private static final float MAX_VERTICAL_FRAGMENTATION = 0.7f;
-    static final int kQuadsPerBuffer = 100;
-    static final int kCoordsPerVertVerts = 3;
-    static final int kCoordsPerVertTex = 2;
-    static final int kVertsPerQuad = 4;
-    static final int kTotalBufferSizeVerts = kQuadsPerBuffer * kVertsPerQuad;
-    static final int kTotalBufferSizeCoordsVerts = kQuadsPerBuffer * kVertsPerQuad * kCoordsPerVertVerts;
-    static final int kTotalBufferSizeCoordsTex = kQuadsPerBuffer * kVertsPerQuad * kCoordsPerVertTex;
-    static final int kTotalBufferSizeBytesVerts = kTotalBufferSizeCoordsVerts * 4;
-    static final int kTotalBufferSizeBytesTex = kTotalBufferSizeCoordsTex * 4;
-    static final int kSizeInBytes_OneVertices_VertexData = kCoordsPerVertVerts * 4;
-    static final int kSizeInBytes_OneVertices_TexData = kCoordsPerVertTex * 4;
-    private Font font;
-    private boolean antialiased;
-    private boolean useFractionalMetrics;
-
-    // Whether we're attempting to use automatic mipmap generation support
-    private boolean mipmap;
-    private RectanglePacker packer;
-    private boolean haveMaxSize;
-    private RenderDelegate renderDelegate;
-    private TextureRenderer cachedBackingStore;
-    private Graphics2D cachedGraphics;
-    private FontRenderContext cachedFontRenderContext;
-    private Map /*<String,Rect>*/ stringLocations = new HashMap /*<String,Rect>*/();
-    private GlyphProducer mGlyphProducer;
-
-    private int numRenderCycles;
-
-    // Need to keep track of whether we're in a beginRendering() /
-    // endRendering() cycle so we can re-enter the exact same state if
-    // we have to reallocate the backing store
-    private boolean inBeginEndPair;
-    private boolean isOrthoMode;
-    private int beginRenderingWidth;
-    private int beginRenderingHeight;
-    private boolean beginRenderingDepthTestDisabled;
-
-    // For resetting the color after disposal of the old backing store
-    private boolean haveCachedColor;
-    private float cachedR;
-    private float cachedG;
-    private float cachedB;
-    private float cachedA;
-    private Color cachedColor;
-    private boolean needToResetColor;
-
-    // For debugging only
-    private Frame dbgFrame;
-
-    // Debugging purposes only
-    private boolean debugged;
-    Pipelined_QuadRenderer mPipelinedQuadRenderer;
-    
-    //emzic: added boolean flag
-    private boolean useVertexArrays = true;
-    
-    //emzic: added boolean flag
-    private boolean isExtensionAvailable_GL_VERSION_1_5;
-    private boolean checkFor_isExtensionAvailable_GL_VERSION_1_5;
-
-    // Whether GL_LINEAR filtering is enabled for the backing store
-    private boolean smoothing = true;
-
-    /** Creates a new TextRenderer with the given font, using no
-        antialiasing or fractional metrics, and the default
-        RenderDelegate. Equivalent to <code>TextRenderer(font, false,
-        false)</code>.
-
-        @param font the font to render with
-    */
-    public TextRenderer(Font font) {
-        this(font, false, false, null, false);
-    }
-
-    /** Creates a new TextRenderer with the given font, using no
-        antialiasing or fractional metrics, and the default
-        RenderDelegate. If <CODE>mipmap</CODE> is true, attempts to use
-        OpenGL's automatic mipmap generation for better smoothing when
-        rendering the TextureRenderer's contents at a distance.
-        Equivalent to <code>TextRenderer(font, false, false)</code>.
-
-        @param font the font to render with
-        @param mipmap whether to attempt use of automatic mipmap generation
-    */
-    public TextRenderer(Font font, boolean mipmap) {
-        this(font, false, false, null, mipmap);
-    }
-
-    /** Creates a new TextRenderer with the given Font, specified font
-        properties, and default RenderDelegate. The
-        <code>antialiased</code> and <code>useFractionalMetrics</code>
-        flags provide control over the same properties at the Java 2D
-        level. No mipmap support is requested. Equivalent to
-        <code>TextRenderer(font, antialiased, useFractionalMetrics,
-        null)</code>.
-
-        @param font the font to render with
-        @param antialiased whether to use antialiased fonts
-        @param useFractionalMetrics whether to use fractional font
-        metrics at the Java 2D level
-    */
-    public TextRenderer(Font font, boolean antialiased,
-                        boolean useFractionalMetrics) {
-        this(font, antialiased, useFractionalMetrics, null, false);
-    }
-
-    /** Creates a new TextRenderer with the given Font, specified font
-        properties, and given RenderDelegate. The
-        <code>antialiased</code> and <code>useFractionalMetrics</code>
-        flags provide control over the same properties at the Java 2D
-        level. The <code>renderDelegate</code> provides more control
-        over the text rendered. No mipmap support is requested.
-
-        @param font the font to render with
-        @param antialiased whether to use antialiased fonts
-        @param useFractionalMetrics whether to use fractional font
-        metrics at the Java 2D level
-        @param renderDelegate the render delegate to use to draw the
-        text's bitmap, or null to use the default one
-    */
-    public TextRenderer(Font font, boolean antialiased,
-                        boolean useFractionalMetrics, RenderDelegate renderDelegate) {
-        this(font, antialiased, useFractionalMetrics, renderDelegate, false);
-    }
-
-    /** Creates a new TextRenderer with the given Font, specified font
-        properties, and given RenderDelegate. The
-        <code>antialiased</code> and <code>useFractionalMetrics</code>
-        flags provide control over the same properties at the Java 2D
-        level. The <code>renderDelegate</code> provides more control
-        over the text rendered. If <CODE>mipmap</CODE> is true, attempts
-        to use OpenGL's automatic mipmap generation for better smoothing
-        when rendering the TextureRenderer's contents at a distance.
-
-        @param font the font to render with
-        @param antialiased whether to use antialiased fonts
-        @param useFractionalMetrics whether to use fractional font
-        metrics at the Java 2D level
-        @param renderDelegate the render delegate to use to draw the
-        text's bitmap, or null to use the default one
-        @param mipmap whether to attempt use of automatic mipmap generation
-    */
-    public TextRenderer(Font font, boolean antialiased,
-                        boolean useFractionalMetrics, RenderDelegate renderDelegate,
-                        boolean mipmap) {
-        this.font = font;
-        this.antialiased = antialiased;
-        this.useFractionalMetrics = useFractionalMetrics;
-        this.mipmap = mipmap;
-
-        // FIXME: consider adjusting the size based on font size
-        // (it will already automatically resize if necessary)
-        packer = new RectanglePacker(new Manager(), kSize, kSize);
-
-        if (renderDelegate == null) {
-            renderDelegate = new DefaultRenderDelegate();
-        }
-
-        this.renderDelegate = renderDelegate;
-
-        mGlyphProducer = new GlyphProducer(font.getNumGlyphs());
-    }
-
-    /** Returns the bounding rectangle of the given String, assuming it
-        was rendered at the origin. See {@link #getBounds(CharSequence)
-        getBounds(CharSequence)}. */
-    public Rectangle2D getBounds(String str) {
-        return getBounds((CharSequence) str);
-    }
-
-    /** Returns the bounding rectangle of the given CharSequence,
-        assuming it was rendered at the origin. The coordinate system of
-        the returned rectangle is Java 2D's, with increasing Y
-        coordinates in the downward direction. The relative coordinate
-        (0, 0) in the returned rectangle corresponds to the baseline of
-        the leftmost character of the rendered string, in similar
-        fashion to the results returned by, for example, {@link
-        java.awt.font.GlyphVector#getVisualBounds}. Most applications
-        will use only the width and height of the returned Rectangle for
-        the purposes of centering or justifying the String. It is not
-        specified which Java 2D bounds ({@link
-        java.awt.font.GlyphVector#getVisualBounds getVisualBounds},
-        {@link java.awt.font.GlyphVector#getPixelBounds getPixelBounds},
-        etc.) the returned bounds correspond to, although every effort
-        is made to ensure an accurate bound. */
-    public Rectangle2D getBounds(CharSequence str) {
-        // FIXME: this should be more optimized and use the glyph cache
-        Rect r = null;
-
-        if ((r = (Rect) stringLocations.get(str)) != null) {
-            TextData data = (TextData) r.getUserData();
-
-            // Reconstitute the Java 2D results based on the cached values
-            return new Rectangle2D.Double(-data.origin().x, -data.origin().y,
-                                          r.w(), r.h());
-        }
-
-        // Must return a Rectangle compatible with the layout algorithm --
-        // must be idempotent
-        return normalize(renderDelegate.getBounds(str, font,
-                                                  getFontRenderContext()));
-    }
-
-    /** Returns the Font this renderer is using. */
-    public Font getFont() {
-        return font;
-    }
-
-    /** Returns a FontRenderContext which can be used for external
-        text-related size computations. This object should be considered
-        transient and may become invalidated between {@link
-        #beginRendering beginRendering} / {@link #endRendering
-        endRendering} pairs. */
-    public FontRenderContext getFontRenderContext() {
-        if (cachedFontRenderContext == null) {
-            cachedFontRenderContext = getGraphics2D().getFontRenderContext();
-        }
-
-        return cachedFontRenderContext;
-    }
-
-    /** Begins rendering with this {@link TextRenderer TextRenderer}
-        into the current OpenGL drawable, pushing the projection and
-        modelview matrices and some state bits and setting up a
-        two-dimensional orthographic projection with (0, 0) as the
-        lower-left coordinate and (width, height) as the upper-right
-        coordinate. Binds and enables the internal OpenGL texture
-        object, sets the texture environment mode to GL_MODULATE, and
-        changes the current color to the last color set with this
-        TextRenderer via {@link #setColor setColor}. This method
-        disables the depth test and is equivalent to
-        beginRendering(width, height, true).
-
-        @param width the width of the current on-screen OpenGL drawable
-        @param height the height of the current on-screen OpenGL drawable
-        @throws javax.media.opengl.GLException If an OpenGL context is not current when this method is called
-    */
-    public void beginRendering(int width, int height) throws GLException {
-        beginRendering(width, height, true);
-    }
-
-    /** Begins rendering with this {@link TextRenderer TextRenderer}
-        into the current OpenGL drawable, pushing the projection and
-        modelview matrices and some state bits and setting up a
-        two-dimensional orthographic projection with (0, 0) as the
-        lower-left coordinate and (width, height) as the upper-right
-        coordinate. Binds and enables the internal OpenGL texture
-        object, sets the texture environment mode to GL_MODULATE, and
-        changes the current color to the last color set with this
-        TextRenderer via {@link #setColor setColor}. Disables the depth
-        test if the disableDepthTest argument is true.
-
-        @param width the width of the current on-screen OpenGL drawable
-        @param height the height of the current on-screen OpenGL drawable
-        @param disableDepthTest whether to disable the depth test
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void beginRendering(int width, int height, boolean disableDepthTest)
-        throws GLException {
-        beginRendering(true, width, height, disableDepthTest);
-    }
-
-    /** Begins rendering of 2D text in 3D with this {@link TextRenderer
-        TextRenderer} into the current OpenGL drawable. Assumes the end
-        user is responsible for setting up the modelview and projection
-        matrices, and will render text using the {@link #draw3D draw3D}
-        method. This method pushes some OpenGL state bits, binds and
-        enables the internal OpenGL texture object, sets the texture
-        environment mode to GL_MODULATE, and changes the current color
-        to the last color set with this TextRenderer via {@link
-        #setColor setColor}.
-
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void begin3DRendering() throws GLException {
-        beginRendering(false, 0, 0, false);
-    }
-
-    /** Changes the current color of this TextRenderer to the supplied
-        one. The default color is opaque white.
-
-        @param color the new color to use for rendering text
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void setColor(Color color) throws GLException {
-        boolean noNeedForFlush = (haveCachedColor && (cachedColor != null) &&
-                                  color.equals(cachedColor));
-
-        if (!noNeedForFlush) {
-            flushGlyphPipeline();
-        }
-
-        getBackingStore().setColor(color);
-        haveCachedColor = true;
-        cachedColor = color;
-    }
-
-    /** Changes the current color of this TextRenderer to the supplied
-        one, where each component ranges from 0.0f - 1.0f. The alpha
-        component, if used, does not need to be premultiplied into the
-        color channels as described in the documentation for {@link
-        com.sun.opengl.util.texture.Texture Texture}, although
-        premultiplied colors are used internally. The default color is
-        opaque white.
-
-        @param r the red component of the new color
-        @param g the green component of the new color
-        @param b the blue component of the new color
-        @param a the alpha component of the new color, 0.0f = completely
-        transparent, 1.0f = completely opaque
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void setColor(float r, float g, float b, float a)
-        throws GLException {
-        boolean noNeedForFlush = (haveCachedColor && (cachedColor == null) &&
-                                  (r == cachedR) && (g == cachedG) && (b == cachedB) &&
-                                  (a == cachedA));
-
-        if (!noNeedForFlush) {
-            flushGlyphPipeline();
-        }
-
-        getBackingStore().setColor(r, g, b, a);
-        haveCachedColor = true;
-        cachedR = r;
-        cachedG = g;
-        cachedB = b;
-        cachedA = a;
-        cachedColor = null;
-    }
-
-    /** Draws the supplied CharSequence at the desired location using
-        the renderer's current color. The baseline of the leftmost
-        character is at position (x, y) specified in OpenGL coordinates,
-        where the origin is at the lower-left of the drawable and the Y
-        coordinate increases in the upward direction.
-
-        @param str the string to draw
-        @param x the x coordinate at which to draw
-        @param y the y coordinate at which to draw
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void draw(CharSequence str, int x, int y) throws GLException {
-        draw3D(str, x, y, 0, 1);
-    }
-
-    /** Draws the supplied String at the desired location using the
-        renderer's current color. See {@link #draw(CharSequence, int,
-        int) draw(CharSequence, int, int)}. */
-    public void draw(String str, int x, int y) throws GLException {
-        draw3D(str, x, y, 0, 1);
-    }
-
-    /** Draws the supplied CharSequence at the desired 3D location using
-        the renderer's current color. The baseline of the leftmost
-        character is placed at position (x, y, z) in the current
-        coordinate system.
-
-        @param str the string to draw
-        @param x the x coordinate at which to draw
-        @param y the y coordinate at which to draw
-        @param z the z coordinate at which to draw
-        @param scaleFactor a uniform scale factor applied to the width and height of the drawn rectangle
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void draw3D(CharSequence str, float x, float y, float z,
-                       float scaleFactor) {
-        internal_draw3D(str, x, y, z, scaleFactor);
-    }
-
-    /** Draws the supplied String at the desired 3D location using the
-        renderer's current color. See {@link #draw3D(CharSequence,
-        float, float, float, float) draw3D(CharSequence, float, float,
-        float, float)}. */
-    public void draw3D(String str, float x, float y, float z, float scaleFactor) {
-        internal_draw3D(str, x, y, z, scaleFactor);
-    }
-
-    /** Returns the pixel width of the given character. */
-    public float getCharWidth(char inChar) {
-        return mGlyphProducer.getGlyphPixelWidth(inChar);
-    }
-
-    /** Causes the TextRenderer to flush any internal caches it may be
-        maintaining and draw its rendering results to the screen. This
-        should be called after each call to draw() if you are setting
-        OpenGL state such as the modelview matrix between calls to
-        draw(). */
-    public void flush() {
-        flushGlyphPipeline();
-    }
-
-    /** Ends a render cycle with this {@link TextRenderer TextRenderer}.
-        Restores the projection and modelview matrices as well as
-        several OpenGL state bits. Should be paired with {@link
-        #beginRendering beginRendering}.
-
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void endRendering() throws GLException {
-        endRendering(true);
-    }
-
-    /** Ends a 3D render cycle with this {@link TextRenderer TextRenderer}.
-        Restores several OpenGL state bits. Should be paired with {@link
-        #begin3DRendering begin3DRendering}.
-
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void end3DRendering() throws GLException {
-        endRendering(false);
-    }
-
-    /** Disposes of all resources this TextRenderer is using. It is not
-        valid to use the TextRenderer after this method is called.
-
-        @throws GLException If an OpenGL context is not current when this method is called
-    */
-    public void dispose() throws GLException {
-        packer.dispose();
-        packer = null;
-        cachedBackingStore = null;
-        cachedGraphics = null;
-        cachedFontRenderContext = null;
-
-        if (dbgFrame != null) {
-            dbgFrame.dispose();
-        }
-    }
-
-    //----------------------------------------------------------------------
-    // Internals only below this point
-    //
-
-    private static Rectangle2D preNormalize(Rectangle2D src) {
-        // Need to round to integer coordinates
-        // Also give ourselves a little slop around the reported
-        // bounds of glyphs because it looks like neither the visual
-        // nor the pixel bounds works perfectly well
-        int minX = (int) Math.floor(src.getMinX()) - 1;
-        int minY = (int) Math.floor(src.getMinY()) - 1;
-        int maxX = (int) Math.ceil(src.getMaxX()) + 1;
-        int maxY = (int) Math.ceil(src.getMaxY()) + 1;
-        return new Rectangle2D.Double(minX, minY, maxX - minX, maxY - minY);
-    }
-
-
-    private Rectangle2D normalize(Rectangle2D src) {
-        // Give ourselves a boundary around each entity on the backing
-        // store in order to prevent bleeding of nearby Strings due to
-        // the fact that we use linear filtering
-
-        // NOTE that this boundary is quite heuristic and is related
-        // to how far away in 3D we may view the text --
-        // heuristically, 1.5% of the font's height
-        int boundary = (int) Math.max(1, 0.015 * font.getSize());
-
-        return new Rectangle2D.Double((int) Math.floor(src.getMinX() - boundary),
-                                      (int) Math.floor(src.getMinY() - boundary),
-                                      (int) Math.ceil(src.getWidth() + 2 * boundary),
-                                      (int) Math.ceil(src.getHeight()) + 2 * boundary);
-    }
-
-    private TextureRenderer getBackingStore() {
-        TextureRenderer renderer = (TextureRenderer) packer.getBackingStore();
-
-        if (renderer != cachedBackingStore) {
-            // Backing store changed since last time; discard any cached Graphics2D
-            if (cachedGraphics != null) {
-                cachedGraphics.dispose();
-                cachedGraphics = null;
-                cachedFontRenderContext = null;
-            }
-
-            cachedBackingStore = renderer;
-        }
-
-        return cachedBackingStore;
-    }
-
-    private Graphics2D getGraphics2D() {
-        TextureRenderer renderer = getBackingStore();
-
-        if (cachedGraphics == null) {
-            cachedGraphics = renderer.createGraphics();
-
-            // Set up composite, font and rendering hints
-            cachedGraphics.setComposite(AlphaComposite.Src);
-            cachedGraphics.setColor(Color.WHITE);
-            cachedGraphics.setFont(font);
-            cachedGraphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
-                                            (antialiased ? RenderingHints.VALUE_TEXT_ANTIALIAS_ON
-                                             : RenderingHints.VALUE_TEXT_ANTIALIAS_OFF));
-            cachedGraphics.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
-                                            (useFractionalMetrics
-                                             ? RenderingHints.VALUE_FRACTIONALMETRICS_ON
-                                             : RenderingHints.VALUE_FRACTIONALMETRICS_OFF));
-        }
-
-        return cachedGraphics;
-    }
-
-    private void beginRendering(boolean ortho, int width, int height,
-                                boolean disableDepthTestForOrtho) {
-        if (DEBUG && !debugged) {
-            debug();
-        }
-
-        inBeginEndPair = true;
-        isOrthoMode = ortho;
-        beginRenderingWidth = width;
-        beginRenderingHeight = height;
-        beginRenderingDepthTestDisabled = disableDepthTestForOrtho;
-
-        if (ortho) {
-            getBackingStore().beginOrthoRendering(width, height,
-                                                  disableDepthTestForOrtho);
-        } else {
-            getBackingStore().begin3DRendering();
-        }
-
-        GL gl = GLU.getCurrentGL();
-
-        // Push client attrib bits used by the pipelined quad renderer
-        gl.glPushClientAttrib((int) GL.GL_ALL_CLIENT_ATTRIB_BITS);
-
-        if (!haveMaxSize) {
-            // Query OpenGL for the maximum texture size and set it in the
-            // RectanglePacker to keep it from expanding too large
-            int[] sz = new int[1];
-            gl.glGetIntegerv(GL.GL_MAX_TEXTURE_SIZE, sz, 0);
-            packer.setMaxSize(sz[0], sz[0]);
-            haveMaxSize = true;
-        }
-
-        if (needToResetColor && haveCachedColor) {
-            if (cachedColor == null) {
-                getBackingStore().setColor(cachedR, cachedG, cachedB, cachedA);
-            } else {
-                getBackingStore().setColor(cachedColor);
-            }
-
-            needToResetColor = false;
-        }
-
-        // Disable future attempts to use mipmapping if TextureRenderer
-        // doesn't support it
-        if (mipmap && !getBackingStore().isUsingAutoMipmapGeneration()) {
-            if (DEBUG) {
-                System.err.println("Disabled mipmapping in TextRenderer");
-            }
-
-            mipmap = false;
-        }
-    }
-
-    /**
-     * emzic: here the call to glBindBuffer crashes on certain graphicscard/driver combinations
-     * this is why the ugly try-catch block has been added, which falls back to the old textrenderer
-     * 
-     * @param ortho
-     * @throws GLException
-     */
-    private void endRendering(boolean ortho) throws GLException {
-        flushGlyphPipeline();
-
-        inBeginEndPair = false;
-
-        GL gl = GLU.getCurrentGL();
-
-        // Pop client attrib bits used by the pipelined quad renderer
-        gl.glPopClientAttrib();
-
-        // The OpenGL spec is unclear about whether this changes the
-        // buffer bindings, so preemptively zero out the GL_ARRAY_BUFFER
-        // binding
-        if (is15Available(gl)) {
-            try {
-                gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
-            } catch (Exception e) {
-                isExtensionAvailable_GL_VERSION_1_5 = false;
-            }
-        }
-
-        if (ortho) {
-            getBackingStore().endOrthoRendering();
-        } else {
-            getBackingStore().end3DRendering();
-        }
-
-        if (++numRenderCycles >= CYCLES_PER_FLUSH) {
-            numRenderCycles = 0;
-
-            if (DEBUG) {
-                System.err.println("Clearing unused entries in endRendering()");
-            }
-
-            clearUnusedEntries();
-        }
-    }
-
-    private void clearUnusedEntries() {
-        final java.util.List deadRects = new ArrayList /*<Rect>*/();
-
-        // Iterate through the contents of the backing store, removing
-        // text strings that haven't been used recently
-        packer.visit(new RectVisitor() {
-                public void visit(Rect rect) {
-                    TextData data = (TextData) rect.getUserData();
-
-                    if (data.used()) {
-                        data.clearUsed();
-                    } else {
-                        deadRects.add(rect);
-                    }
-                }
-            });
-
-        for (Iterator iter = deadRects.iterator(); iter.hasNext();) {
-            Rect r = (Rect) iter.next();
-            packer.remove(r);
-            stringLocations.remove(((TextData) r.getUserData()).string());
-
-            int unicodeToClearFromCache = ((TextData) r.getUserData()).unicodeID;
-
-            if (unicodeToClearFromCache > 0) {
-                mGlyphProducer.clearCacheEntry(unicodeToClearFromCache);
-            }
-
-            //      if (DEBUG) {
-            //        Graphics2D g = getGraphics2D();
-            //        g.setComposite(AlphaComposite.Clear);
-            //        g.fillRect(r.x(), r.y(), r.w(), r.h());
-            //        g.setComposite(AlphaComposite.Src);
-            //      }
-        }
-
-        // If we removed dead rectangles this cycle, try to do a compaction
-        float frag = packer.verticalFragmentationRatio();
-
-        if (!deadRects.isEmpty() && (frag > MAX_VERTICAL_FRAGMENTATION)) {
-            if (DEBUG) {
-                System.err.println(
-                                   "Compacting TextRenderer backing store due to vertical fragmentation " +
-                                   frag);
-            }
-
-            packer.compact();
-        }
-
-        if (DEBUG) {
-            getBackingStore().markDirty(0, 0, getBackingStore().getWidth(),
-                                        getBackingStore().getHeight());
-        }
-    }
-
-    private void internal_draw3D(CharSequence str, float x, float y, float z,
-                                 float scaleFactor) {
-        List/*<Glyph>*/ glyphs = mGlyphProducer.getGlyphs(str);
-        for (Iterator iter = glyphs.iterator(); iter.hasNext(); ) {
-            Glyph glyph = (Glyph) iter.next();
-            float advance = glyph.draw3D(x, y, z, scaleFactor);
-            x += advance * scaleFactor;
-        }
-    }
-
-    private void flushGlyphPipeline() {
-        if (mPipelinedQuadRenderer != null) {
-            mPipelinedQuadRenderer.draw();
-        }
-    }
-
-    private void draw3D_ROBUST(CharSequence str, float x, float y, float z,
-                               float scaleFactor) {
-        String curStr;
-        if (str instanceof String) {
-            curStr = (String) str;
-        } else {
-            curStr = str.toString();
-        }
-
-        // Look up the string on the backing store
-        Rect rect = (Rect) stringLocations.get(curStr);
-
-        if (rect == null) {
-            // Rasterize this string and place it on the backing store
-            Graphics2D g = getGraphics2D();
-            Rectangle2D origBBox = preNormalize(renderDelegate.getBounds(curStr, font, getFontRenderContext()));
-            Rectangle2D bbox = normalize(origBBox);
-            Point origin = new Point((int) -bbox.getMinX(),
-                                     (int) -bbox.getMinY());
-            rect = new Rect(0, 0, (int) bbox.getWidth(),
-                            (int) bbox.getHeight(),
-                            new TextData(curStr, origin, origBBox, -1));
-
-            packer.add(rect);
-            stringLocations.put(curStr, rect);
-
-            // Re-fetch the Graphics2D in case the addition of the rectangle
-            // caused the old backing store to be thrown away
-            g = getGraphics2D();
-
-            // OK, should now have an (x, y) for this rectangle; rasterize
-            // the String
-            int strx = rect.x() + origin.x;
-            int stry = rect.y() + origin.y;
-
-            // Clear out the area we're going to draw into
-            g.setComposite(AlphaComposite.Clear);
-            g.fillRect(rect.x(), rect.y(), rect.w(), rect.h());
-            g.setComposite(AlphaComposite.Src);
-
-            // Draw the string
-            renderDelegate.draw(g, curStr, strx, stry);
-
-            if (DRAW_BBOXES) {
-                TextData data = (TextData) rect.getUserData();
-                // Draw a bounding box on the backing store
-                g.drawRect(strx - data.origOriginX(),
-                           stry - data.origOriginY(),
-                           (int) data.origRect().getWidth(),
-                           (int) data.origRect().getHeight());
-                g.drawRect(strx - data.origin().x,
-                           stry - data.origin().y,
-                           rect.w(),
-                           rect.h());
-            }
-
-            // Mark this region of the TextureRenderer as dirty
-            getBackingStore().markDirty(rect.x(), rect.y(), rect.w(),
-                                        rect.h());
-        }
-
-        // OK, now draw the portion of the backing store to the screen
-        TextureRenderer renderer = getBackingStore();
-
-        // NOTE that the rectangles managed by the packer have their
-        // origin at the upper-left but the TextureRenderer's origin is
-        // at its lower left!!!
-        TextData data = (TextData) rect.getUserData();
-        data.markUsed();
-
-        Rectangle2D origRect = data.origRect();
-        
-        // Align the leftmost point of the baseline to the (x, y, z) coordinate requested
-        renderer.draw3DRect(x - (scaleFactor * data.origOriginX()),
-                            y - (scaleFactor * ((float) origRect.getHeight() - data.origOriginY())), z,
-                            rect.x() + (data.origin().x - data.origOriginX()),
-                            renderer.getHeight() - rect.y() - (int) origRect.getHeight() -
-                              (data.origin().y - data.origOriginY()),
-                            (int) origRect.getWidth(), (int) origRect.getHeight(), scaleFactor);
-    }
-
-    //----------------------------------------------------------------------
-    // Debugging functionality
-    //
-    private void debug() {
-        dbgFrame = new Frame("TextRenderer Debug Output");
-
-        GLCanvas dbgCanvas = new GLCanvas(new GLCapabilities(), null,
-                                          GLContext.getCurrent(), null);
-        dbgCanvas.addGLEventListener(new DebugListener(dbgFrame));
-        dbgFrame.add(dbgCanvas);
-
-        final FPSAnimator anim = new FPSAnimator(dbgCanvas, 10);
-        dbgFrame.addWindowListener(new WindowAdapter() {
-                public void windowClosing(WindowEvent e) {
-                    // Run this on another thread than the AWT event queue to
-                    // make sure the call to Animator.stop() completes before
-                    // exiting
-                    new Thread(new Runnable() {
-                            public void run() {
-                                anim.stop();
-                            }
-                        }).start();
-                }
-            });
-        dbgFrame.setSize(kSize, kSize);
-        dbgFrame.setVisible(true);
-        anim.start();
-        debugged = true;
-    }
-
-    /** Class supporting more full control over the process of rendering
-        the bitmapped text. Allows customization of whether the backing
-        store text bitmap is full-color or intensity only, the size of
-        each individual rendered text rectangle, and the contents of
-        each individual rendered text string. The default implementation
-        of this interface uses an intensity-only texture, a
-        closely-cropped rectangle around the text, and renders text
-        using the color white, which is modulated by the set color
-        during the rendering process. */
-    public static interface RenderDelegate {
-        /** Indicates whether the backing store of this TextRenderer
-            should be intensity-only (the default) or full-color. */
-        public boolean intensityOnly();
-
-        /** Computes the bounds of the given String relative to the
-            origin. */
-        public Rectangle2D getBounds(String str, Font font,
-                                     FontRenderContext frc);
-
-        /** Computes the bounds of the given character sequence relative
-            to the origin. */
-        public Rectangle2D getBounds(CharSequence str, Font font,
-                                     FontRenderContext frc);
-
-        /** Computes the bounds of the given GlyphVector, already
-            assumed to have been created for a particular Font,
-            relative to the origin. */
-        public Rectangle2D getBounds(GlyphVector gv, FontRenderContext frc);
-
-        /** Render the passed character sequence at the designated
-            location using the supplied Graphics2D instance. The
-            surrounding region will already have been cleared to the RGB
-            color (0, 0, 0) with zero alpha. The initial drawing context
-            of the passed Graphics2D will be set to use
-            AlphaComposite.Src, the color white, the Font specified in the
-            TextRenderer's constructor, and the rendering hints specified
-            in the TextRenderer constructor.  Changes made by the end user
-            may be visible in successive calls to this method, but are not
-            guaranteed to be preserved.  Implementors of this method
-            should reset the Graphics2D's state to that desired each time
-            this method is called, in particular those states which are
-            not the defaults. */
-        public void draw(Graphics2D graphics, String str, int x, int y);
-
-        /** Render the passed GlyphVector at the designated location using
-            the supplied Graphics2D instance. The surrounding region will
-            already have been cleared to the RGB color (0, 0, 0) with zero
-            alpha. The initial drawing context of the passed Graphics2D
-            will be set to use AlphaComposite.Src, the color white, the
-            Font specified in the TextRenderer's constructor, and the
-            rendering hints specified in the TextRenderer constructor.
-            Changes made by the end user may be visible in successive
-            calls to this method, but are not guaranteed to be preserved.
-            Implementors of this method should reset the Graphics2D's
-            state to that desired each time this method is called, in
-            particular those states which are not the defaults. */
-        public void drawGlyphVector(Graphics2D graphics, GlyphVector str,
-                                    int x, int y);
-    }
-
-    private static class CharSequenceIterator implements CharacterIterator {
-        CharSequence mSequence;
-        int mLength;
-        int mCurrentIndex;
-
-        CharSequenceIterator() {
-        }
-
-        CharSequenceIterator(CharSequence sequence) {
-            initFromCharSequence(sequence);
-        }
-
-        public void initFromCharSequence(CharSequence sequence) {
-            mSequence = sequence;
-            mLength = mSequence.length();
-            mCurrentIndex = 0;
-        }
-
-        public char last() {
-            mCurrentIndex = Math.max(0, mLength - 1);
-
-            return current();
-        }
-
-        public char current() {
-            if ((mLength == 0) || (mCurrentIndex >= mLength)) {
-                return CharacterIterator.DONE;
-            }
-
-            return mSequence.charAt(mCurrentIndex);
-        }
-
-        public char next() {
-            mCurrentIndex++;
-
-            return current();
-        }
-
-        public char previous() {
-            mCurrentIndex = Math.max(mCurrentIndex - 1, 0);
-
-            return current();
-        }
-
-        public char setIndex(int position) {
-            mCurrentIndex = position;
-
-            return current();
-        }
-
-        public int getBeginIndex() {
-            return 0;
-        }
-
-        public int getEndIndex() {
-            return mLength;
-        }
-
-        public int getIndex() {
-            return mCurrentIndex;
-        }
-
-        public Object clone() {
-            CharSequenceIterator iter = new CharSequenceIterator(mSequence);
-            iter.mCurrentIndex = mCurrentIndex;
-
-            return iter;
-        }
-
-        public char first() {
-            if (mLength == 0) {
-                return CharacterIterator.DONE;
-            }
-
-            mCurrentIndex = 0;
-
-            return current();
-        }
-    }
-
-    // Data associated with each rectangle of text
-    static class TextData {
-        // Back-pointer to String this TextData describes, if it
-        // represents a String rather than a single glyph
-        private String str;
-
-        // If this TextData represents a single glyph, this is its
-        // unicode ID
-        int unicodeID;
-
-        // The following must be defined and used VERY precisely. This is
-        // the offset from the upper-left corner of this rectangle (Java
-        // 2D coordinate system) at which the string must be rasterized in
-        // order to fit within the rectangle -- the leftmost point of the
-        // baseline.
-        private Point origin;
-
-        // This represents the pre-normalized rectangle, which fits
-        // within the rectangle on the backing store. We keep a
-        // one-pixel border around entries on the backing store to
-        // prevent bleeding of adjacent letters when using GL_LINEAR
-        // filtering for rendering. The origin of this rectangle is
-        // equivalent to the origin above.
-        private Rectangle2D origRect;
-
-        private boolean used; // Whether this text was used recently
-
-        TextData(String str, Point origin, Rectangle2D origRect, int unicodeID) {
-            this.str = str;
-            this.origin = origin;
-            this.origRect = origRect;
-            this.unicodeID = unicodeID;
-        }
-
-        String string() {
-            return str;
-        }
-
-        Point origin() {
-            return origin;
-        }
-
-        // The following three methods are used to locate the glyph
-        // within the expanded rectangle coming from normalize()
-        int origOriginX() {
-            return (int) -origRect.getMinX();
-        }
-
-        int origOriginY() {
-            return (int) -origRect.getMinY();
-        }
-
-        Rectangle2D origRect() {
-            return origRect;
-        }
-
-        boolean used() {
-            return used;
-        }
-
-        void markUsed() {
-            used = true;
-        }
-
-        void clearUsed() {
-            used = false;
-        }
-    }
-
-    class Manager implements BackingStoreManager {
-        private Graphics2D g;
-
-        public Object allocateBackingStore(int w, int h) {
-            // FIXME: should consider checking Font's attributes to see
-            // whether we're likely to need to support a full RGBA backing
-            // store (i.e., non-default Paint, foreground color, etc.), but
-            // for now, let's just be more efficient
-            TextureRenderer renderer;
-
-            if (renderDelegate.intensityOnly()) {
-                renderer = TextureRenderer.createAlphaOnlyRenderer(w, h, mipmap);
-            } else {
-                renderer = new TextureRenderer(w, h, true, mipmap);
-            }
-            renderer.setSmoothing(smoothing);
-
-            if (DEBUG) {
-                System.err.println(" TextRenderer allocating backing store " +
-                                   w + " x " + h);
-            }
-
-            return renderer;
-        }
-
-        public void deleteBackingStore(Object backingStore) {
-            ((TextureRenderer) backingStore).dispose();
-        }
-
-        public boolean preExpand(Rect cause, int attemptNumber) {
-            // Only try this one time; clear out potentially obsolete entries
-            // NOTE: this heuristic and the fact that it clears the used bit
-            // of all entries seems to cause cycling of entries in some
-            // situations, where the backing store becomes small compared to
-            // the amount of text on the screen (see the TextFlow demo) and
-            // the entries continually cycle in and out of the backing
-            // store, decreasing performance. If we added a little age
-            // information to the entries, and only cleared out entries
-            // above a certain age, this behavior would be eliminated.
-            // However, it seems the system usually stabilizes itself, so
-            // for now we'll just keep things simple. Note that if we don't
-            // clear the used bit here, the backing store tends to increase
-            // very quickly to its maximum size, at least with the TextFlow
-            // demo when the text is being continually re-laid out.
-            if (attemptNumber == 0) {
-                if (DEBUG) {
-                    System.err.println(
-                        "Clearing unused entries in preExpand(): attempt number " +
-                        attemptNumber);
-                }
-
-                if (inBeginEndPair) {
-                    // Draw any outstanding glyphs
-                    flush();
-                }
-
-                clearUnusedEntries();
-
-                return true;
-            }
-
-            return false;
-        }
-
-        public void additionFailed(Rect cause, int attemptNumber) {
-            // Heavy hammer -- might consider doing something different
-            packer.clear();
-            stringLocations.clear();
-            mGlyphProducer.clearAllCacheEntries();
-
-            if (DEBUG) {
-                System.err.println(
-                                   " *** Cleared all text because addition failed ***");
-            }
-        }
-
-        public void beginMovement(Object oldBackingStore, Object newBackingStore) {
-            // Exit the begin / end pair if necessary
-            if (inBeginEndPair) {
-                // Draw any outstanding glyphs
-                flush();
-
-                GL gl = GLU.getCurrentGL();
-
-                // Pop client attrib bits used by the pipelined quad renderer
-                gl.glPopClientAttrib();
-
-                // The OpenGL spec is unclear about whether this changes the
-                // buffer bindings, so preemptively zero out the GL_ARRAY_BUFFER
-                // binding
-                if (is15Available(gl)) {
-                    try {
-                        gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
-                    } catch (Exception e) {
-                        isExtensionAvailable_GL_VERSION_1_5 = false;
-                    }
-                }
-
-                if (isOrthoMode) {
-                    ((TextureRenderer) oldBackingStore).endOrthoRendering();
-                } else {
-                    ((TextureRenderer) oldBackingStore).end3DRendering();
-                }
-            }
-
-            TextureRenderer newRenderer = (TextureRenderer) newBackingStore;
-            g = newRenderer.createGraphics();
-        }
-
-        public void move(Object oldBackingStore, Rect oldLocation,
-                         Object newBackingStore, Rect newLocation) {
-            TextureRenderer oldRenderer = (TextureRenderer) oldBackingStore;
-            TextureRenderer newRenderer = (TextureRenderer) newBackingStore;
-
-            if (oldRenderer == newRenderer) {
-                // Movement on the same backing store -- easy case
-                g.copyArea(oldLocation.x(), oldLocation.y(), oldLocation.w(),
-                           oldLocation.h(), newLocation.x() - oldLocation.x(),
-                           newLocation.y() - oldLocation.y());
-            } else {
-                // Need to draw from the old renderer's image into the new one
-                Image img = oldRenderer.getImage();
-                g.drawImage(img, newLocation.x(), newLocation.y(),
-                            newLocation.x() + newLocation.w(),
-                            newLocation.y() + newLocation.h(), oldLocation.x(),
-                            oldLocation.y(), oldLocation.x() + oldLocation.w(),
-                            oldLocation.y() + oldLocation.h(), null);
-            }
-        }
-
-        public void endMovement(Object oldBackingStore, Object newBackingStore) {
-            g.dispose();
-
-            // Sync the whole surface
-            TextureRenderer newRenderer = (TextureRenderer) newBackingStore;
-            newRenderer.markDirty(0, 0, newRenderer.getWidth(),
-                                  newRenderer.getHeight());
-
-            // Re-enter the begin / end pair if necessary
-            if (inBeginEndPair) {
-                if (isOrthoMode) {
-                    ((TextureRenderer) newBackingStore).beginOrthoRendering(beginRenderingWidth,
-                                                                            beginRenderingHeight, beginRenderingDepthTestDisabled);
-                } else {
-                    ((TextureRenderer) newBackingStore).begin3DRendering();
-                }
-
-                // Push client attrib bits used by the pipelined quad renderer
-                GL gl = GLU.getCurrentGL();
-                gl.glPushClientAttrib((int) GL.GL_ALL_CLIENT_ATTRIB_BITS);
-
-                if (haveCachedColor) {
-                    if (cachedColor == null) {
-                        ((TextureRenderer) newBackingStore).setColor(cachedR,
-                                                                     cachedG, cachedB, cachedA);
-                    } else {
-                        ((TextureRenderer) newBackingStore).setColor(cachedColor);
-                    }
-                }
-            } else {
-                needToResetColor = true;
-            }
-        }
-    }
-
-    public static class DefaultRenderDelegate implements RenderDelegate {
-        public boolean intensityOnly() {
-            return true;
-        }
-
-        public Rectangle2D getBounds(CharSequence str, Font font,
-                                     FontRenderContext frc) {
-            return getBounds(font.createGlyphVector(frc,
-                                                    new CharSequenceIterator(str)),
-                             frc);
-        }
-
-        public Rectangle2D getBounds(String str, Font font,
-                                     FontRenderContext frc) {
-            return getBounds(font.createGlyphVector(frc, str), frc);
-        }
-
-        public Rectangle2D getBounds(GlyphVector gv, FontRenderContext frc) {
-            return gv.getVisualBounds();
-        }
-
-        public void drawGlyphVector(Graphics2D graphics, GlyphVector str,
-                                    int x, int y) {
-            graphics.drawGlyphVector(str, x, y);
-        }
-
-        public void draw(Graphics2D graphics, String str, int x, int y) {
-            graphics.drawString(str, x, y);
-        }
-    }
-
-    //----------------------------------------------------------------------
-    // Glyph-by-glyph rendering support
-    //
-
-    // A temporary to prevent excessive garbage creation
-    private char[] singleUnicode = new char[1];
-
-    /** A Glyph represents either a single unicode glyph or a
-        substring of characters to be drawn. The reason for the dual
-        behavior is so that we can take in a sequence of unicode
-        characters and partition them into runs of individual glyphs,
-        but if we encounter complex text and/or unicode sequences we
-        don't understand, we can render them using the
-        string-by-string method. <P>
-
-        Glyphs need to be able to re-upload themselves to the backing
-        store on demand as we go along in the render sequence.
-    */
-
-    class Glyph {
-        // If this Glyph represents an individual unicode glyph, this
-        // is its unicode ID. If it represents a String, this is -1.
-        private int unicodeID;
-        // If the above field isn't -1, then these fields are used.
-        // The glyph code in the font
-        private int glyphCode;
-        // The GlyphProducer which created us
-        private GlyphProducer producer;
-        // The advance of this glyph
-        private float advance;
-        // The GlyphVector for this single character; this is passed
-        // in during construction but cleared during the upload
-        // process
-        private GlyphVector singleUnicodeGlyphVector;
-        // The rectangle of this glyph on the backing store, or null
-        // if it has been cleared due to space pressure
-        private Rect glyphRectForTextureMapping;
-        // If this Glyph represents a String, this is the sequence of
-        // characters
-        private String str;
-        // Whether we need a valid advance when rendering this string
-        // (i.e., whether it has other single glyphs coming after it)
-        private boolean needAdvance;
-
-        // Creates a Glyph representing an individual Unicode character
-        public Glyph(int unicodeID,
-                     int glyphCode,
-                     float advance,
-                     GlyphVector singleUnicodeGlyphVector,
-                     GlyphProducer producer) {
-            this.unicodeID = unicodeID;
-            this.glyphCode = glyphCode;
-            this.advance = advance;
-            this.singleUnicodeGlyphVector = singleUnicodeGlyphVector;
-            this.producer = producer;
-        }
-
-        // Creates a Glyph representing a sequence of characters, with
-        // an indication of whether additional single glyphs are being
-        // rendered after it
-        public Glyph(String str, boolean needAdvance) {
-            this.str = str;
-            this.needAdvance = needAdvance;
-        }
-
-        /** Returns this glyph's unicode ID */
-        public int getUnicodeID() {
-            return unicodeID;
-        }
-
-        /** Returns this glyph's (font-specific) glyph code */
-        public int getGlyphCode() {
-            return glyphCode;
-        }
-
-        /** Returns the advance for this glyph */
-        public float getAdvance() {
-            return advance;
-        }
-
-        /** Draws this glyph and returns the (x) advance for this glyph */
-        public float draw3D(float inX, float inY, float z, float scaleFactor) {
-            if (str != null) {
-                draw3D_ROBUST(str, inX, inY, z, scaleFactor);
-                if (!needAdvance) {
-                    return 0;
-                }
-                // Compute and return the advance for this string
-                GlyphVector gv = font.createGlyphVector(getFontRenderContext(), str);
-                float totalAdvance = 0;
-                for (int i = 0; i < gv.getNumGlyphs(); i++) {
-                    totalAdvance += gv.getGlyphMetrics(i).getAdvance();
-                }
-                return totalAdvance;
-            }
-
-            // This is the code path taken for individual glyphs
-            if (glyphRectForTextureMapping == null) {
-                upload();
-            }
-
-            try {
-                if (mPipelinedQuadRenderer == null) {
-                    mPipelinedQuadRenderer = new Pipelined_QuadRenderer();
-                }
-
-                TextureRenderer renderer = getBackingStore();
-                // Handles case where NPOT texture is used for backing store
-                TextureCoords wholeImageTexCoords = renderer.getTexture().getImageTexCoords();
-                float xScale = wholeImageTexCoords.right();
-                float yScale = wholeImageTexCoords.bottom();
-
-                Rect rect = glyphRectForTextureMapping;
-                TextData data = (TextData) rect.getUserData();
-                data.markUsed();
-
-                Rectangle2D origRect = data.origRect();
-
-                float x = inX - (scaleFactor * data.origOriginX());
-                float y = inY - (scaleFactor * ((float) origRect.getHeight() - data.origOriginY()));
-
-                int texturex = rect.x() + (data.origin().x - data.origOriginX());
-                int texturey = renderer.getHeight() - rect.y() - (int) origRect.getHeight() -
-                    (data.origin().y - data.origOriginY());
-                int width = (int) origRect.getWidth();
-                int height = (int) origRect.getHeight();
-
-                float tx1 = xScale * (float) texturex / (float) renderer.getWidth();
-                float ty1 = yScale * (1.0f -
-                                      ((float) texturey / (float) renderer.getHeight()));
-                float tx2 = xScale * (float) (texturex + width) / (float) renderer.getWidth();
-                float ty2 = yScale * (1.0f -
-                                      ((float) (texturey + height) / (float) renderer.getHeight()));
-
-                mPipelinedQuadRenderer.glTexCoord2f(tx1, ty1);
-                mPipelinedQuadRenderer.glVertex3f(x, y, z);
-                mPipelinedQuadRenderer.glTexCoord2f(tx2, ty1);
-                mPipelinedQuadRenderer.glVertex3f(x + (width * scaleFactor), y,
-                                                  z);
-                mPipelinedQuadRenderer.glTexCoord2f(tx2, ty2);
-                mPipelinedQuadRenderer.glVertex3f(x + (width * scaleFactor),
-                                                  y + (height * scaleFactor), z);
-                mPipelinedQuadRenderer.glTexCoord2f(tx1, ty2);
-                mPipelinedQuadRenderer.glVertex3f(x,
-                                                  y + (height * scaleFactor), z);
-            } catch (Exception e) {
-                e.printStackTrace();
-            }
-            return advance;
-        }
-
-        /** Notifies this glyph that it's been cleared out of the cache */
-        public void clear() {
-            glyphRectForTextureMapping = null;
-        }
-
-        private void upload() {
-            GlyphVector gv = getGlyphVector();
-            Rectangle2D origBBox = preNormalize(renderDelegate.getBounds(gv, getFontRenderContext()));
-            Rectangle2D bbox = normalize(origBBox);
-            Point origin = new Point((int) -bbox.getMinX(),
-                                     (int) -bbox.getMinY());
-            Rect rect = new Rect(0, 0, (int) bbox.getWidth(),
-                                 (int) bbox.getHeight(),
-                                 new TextData(null, origin, origBBox, unicodeID));
-            packer.add(rect);
-            glyphRectForTextureMapping = rect;
-            Graphics2D g = getGraphics2D();
-            // OK, should now have an (x, y) for this rectangle; rasterize
-            // the glyph
-            int strx = rect.x() + origin.x;
-            int stry = rect.y() + origin.y;
-
-            // Clear out the area we're going to draw into
-            g.setComposite(AlphaComposite.Clear);
-            g.fillRect(rect.x(), rect.y(), rect.w(), rect.h());
-            g.setComposite(AlphaComposite.Src);
-
-            // Draw the string
-            renderDelegate.drawGlyphVector(g, gv, strx, stry);
-
-            if (DRAW_BBOXES) {
-                TextData data = (TextData) rect.getUserData();
-                // Draw a bounding box on the backing store
-                g.drawRect(strx - data.origOriginX(),
-                           stry - data.origOriginY(),
-                           (int) data.origRect().getWidth(),
-                           (int) data.origRect().getHeight());
-                g.drawRect(strx - data.origin().x,
-                           stry - data.origin().y,
-                           rect.w(),
-                           rect.h());
-            }
-
-            // Mark this region of the TextureRenderer as dirty
-            getBackingStore().markDirty(rect.x(), rect.y(), rect.w(),
-                                        rect.h());
-            // Re-register ourselves with our producer
-            producer.register(this);
-        }
-
-        private GlyphVector getGlyphVector() {
-            GlyphVector gv = singleUnicodeGlyphVector;
-            if (gv != null) {
-                singleUnicodeGlyphVector = null; // Don't need this anymore
-                return gv;
-            }
-            singleUnicode[0] = (char) unicodeID;
-            return font.createGlyphVector(getFontRenderContext(), singleUnicode);
-        }
-    }
-
-    class GlyphProducer {
-        final int undefined = -2;
-        FontRenderContext fontRenderContext;
-        List/*<Glyph>*/ glyphsOutput = new ArrayList/*<Glyph>*/();
-        // The mapping from unicode character to font-specific glyph ID
-        int[] unicodes2Glyphs;
-        // The mapping from glyph ID to Glyph
-        Glyph[] glyphCache;
-        // We re-use this for each incoming string
-        CharSequenceIterator iter = new CharSequenceIterator();
-
-        GlyphProducer(int fontLengthInGlyphs) {
-            unicodes2Glyphs = new int[512];
-            glyphCache = new Glyph[fontLengthInGlyphs];
-            clearAllCacheEntries();
-        }
-
-        public List/*<Glyph>*/ getGlyphs(CharSequence inString) {
-            glyphsOutput.clear();
-            iter.initFromCharSequence(inString);
-            GlyphVector fullRunGlyphVector = font.createGlyphVector(getFontRenderContext(),
-                                                                    iter);
-            boolean complex = (fullRunGlyphVector.getLayoutFlags() != 0);
-            if (complex || DISABLE_GLYPH_CACHE) {
-                // Punt to the robust version of the renderer
-                glyphsOutput.add(new Glyph(inString.toString(), false));
-                return glyphsOutput;
-            }
-
-            int lengthInGlyphs = fullRunGlyphVector.getNumGlyphs();
-            int i = 0;
-            while (i < lengthInGlyphs) {
-                Glyph glyph = getGlyph(inString, fullRunGlyphVector, i);
-                if (glyph != null) {
-                    glyphsOutput.add(glyph);
-                    i++;
-                } else {
-                    // Assemble a run of characters that don't fit in
-                    // the cache
-                    StringBuffer buf = new StringBuffer();
-                    while (i < lengthInGlyphs &&
-                           getGlyph(inString, fullRunGlyphVector, i) == null) {
-                        buf.append(inString.charAt(i++));
-                    }
-                    glyphsOutput.add(new Glyph(buf.toString(),
-                                               // Any more glyphs after this run?
-                                               i < lengthInGlyphs));
-                }
-            }
-            return glyphsOutput;
-        }
-
-        public void clearCacheEntry(int unicodeID) {
-            int glyphID = unicodes2Glyphs[unicodeID];
-            if (glyphID != undefined) {
-                Glyph glyph = glyphCache[glyphID];
-                if (glyph != null) {
-                    glyph.clear();
-                }
-                glyphCache[glyphID] = null;
-            }
-            unicodes2Glyphs[unicodeID] = undefined;
-        }
-
-        public void clearAllCacheEntries() {
-            for (int i = 0; i < unicodes2Glyphs.length; i++) {
-                clearCacheEntry(i);
-            }
-        }
-
-        public void register(Glyph glyph) {
-            unicodes2Glyphs[glyph.getUnicodeID()] = glyph.getGlyphCode();
-            glyphCache[glyph.getGlyphCode()] = glyph;
-        }
-
-        public float getGlyphPixelWidth(char unicodeID) {
-            Glyph glyph = getGlyph(unicodeID);
-            if (glyph != null) {
-                return glyph.getAdvance();
-            }
-
-            // Have to do this the hard / uncached way
-            singleUnicode[0] = unicodeID;
-            GlyphVector gv = font.createGlyphVector(fontRenderContext,
-                                                                    singleUnicode);
-            return gv.getGlyphMetrics(0).getAdvance();
-        }
-
-        // Returns a glyph object for this single glyph. Returns null
-        // if the unicode or glyph ID would be out of bounds of the
-        // glyph cache.
-        private Glyph getGlyph(CharSequence inString,
-                               GlyphVector fullRunGlyphVector,
-                               int index) {
-            char unicodeID = inString.charAt(index);
-
-            if (unicodeID >= unicodes2Glyphs.length) {
-                return null;
-            }
-
-            int glyphID = unicodes2Glyphs[unicodeID];
-            if (glyphID != undefined) {
-                return glyphCache[glyphID];
-            }
-
-            // Must fabricate the glyph
-            singleUnicode[0] = unicodeID;
-            GlyphVector gv = font.createGlyphVector(getFontRenderContext(), singleUnicode);
-            return getGlyph(unicodeID, gv, fullRunGlyphVector.getGlyphMetrics(index));
-        }
-
-        // It's unclear whether this variant might produce less
-        // optimal results than if we can see the entire GlyphVector
-        // for the incoming string
-        private Glyph getGlyph(int unicodeID) {
-            if (unicodeID >= unicodes2Glyphs.length) {
-                return null;
-            }
-
-            int glyphID = unicodes2Glyphs[unicodeID];
-            if (glyphID != undefined) {
-                return glyphCache[glyphID];
-            }
-            singleUnicode[0] = (char) unicodeID;
-            GlyphVector gv = font.createGlyphVector(getFontRenderContext(), singleUnicode);
-            return getGlyph(unicodeID, gv, gv.getGlyphMetrics(0));
-        }
-
-        private Glyph getGlyph(int unicodeID,
-                               GlyphVector singleUnicodeGlyphVector,
-                               GlyphMetrics metrics) {
-            int glyphCode = singleUnicodeGlyphVector.getGlyphCode(0);
-            // Have seen huge glyph codes (65536) coming out of some fonts in some Unicode situations
-            if (glyphCode >= glyphCache.length) {
-                return null;
-            }
-            Glyph glyph = new Glyph(unicodeID,
-                                    glyphCode,
-                                    metrics.getAdvance(),
-                                    singleUnicodeGlyphVector,
-                                    this);
-            register(glyph);
-            return glyph;
-        }
-    }
-
-    class Pipelined_QuadRenderer {
-        int mOutstandingGlyphsVerticesPipeline = 0;
-        FloatBuffer mTexCoords;
-        FloatBuffer mVertCoords;
-        boolean usingVBOs;
-        int mVBO_For_ResuableTileVertices;
-        int mVBO_For_ResuableTileTexCoords;
-
-        Pipelined_QuadRenderer() {
-            GL gl = GLU.getCurrentGL();
-            mVertCoords = BufferUtil.newFloatBuffer(kTotalBufferSizeCoordsVerts);
-            mTexCoords = BufferUtil.newFloatBuffer(kTotalBufferSizeCoordsTex);
-
-            usingVBOs = is15Available(gl);
-
-            if (usingVBOs) {
-                try {
-                    int[] vbos = new int[2];
-                    gl.glGenBuffers(2, IntBuffer.wrap(vbos));
-
-                    mVBO_For_ResuableTileVertices = vbos[0];
-                    mVBO_For_ResuableTileTexCoords = vbos[1];
-
-                    gl.glBindBuffer(GL.GL_ARRAY_BUFFER,
-                                    mVBO_For_ResuableTileVertices);
-                    gl.glBufferData(GL.GL_ARRAY_BUFFER, kTotalBufferSizeBytesVerts,
-                                    null, GL.GL_STREAM_DRAW); // stream draw because this is a single quad use pipeline
-
-                    gl.glBindBuffer(GL.GL_ARRAY_BUFFER,
-                                    mVBO_For_ResuableTileTexCoords);
-                    gl.glBufferData(GL.GL_ARRAY_BUFFER, kTotalBufferSizeBytesTex,
-                                    null, GL.GL_STREAM_DRAW); // stream draw because this is a single quad use pipeline
-                } catch (Exception e) {
-                    isExtensionAvailable_GL_VERSION_1_5 = false;
-                    usingVBOs = false;
-                }
-            }
-        }
-
-        public void glTexCoord2f(float v, float v1) {
-            mTexCoords.put(v);
-            mTexCoords.put(v1);
-        }
-
-        public void glVertex3f(float inX, float inY, float inZ) {
-            mVertCoords.put(inX);
-            mVertCoords.put(inY);
-            mVertCoords.put(inZ);
-
-            mOutstandingGlyphsVerticesPipeline++;
-
-            if (mOutstandingGlyphsVerticesPipeline >= kTotalBufferSizeVerts) {
-                this.draw();
-            }
-        }
-
-        private void draw() {
-            if (useVertexArrays) {
-                drawVertexArrays();
-            } else {
-                drawIMMEDIATE();
-            }
-        }
-
-        private void drawVertexArrays() {
-            if (mOutstandingGlyphsVerticesPipeline > 0) {
-                GL gl = GLU.getCurrentGL();
-
-                TextureRenderer renderer = getBackingStore();
-                Texture texture = renderer.getTexture(); // triggers texture uploads.  Maybe this should be more obvious?
-
-                mVertCoords.rewind();
-                mTexCoords.rewind();
-
-                gl.glEnableClientState(GL.GL_VERTEX_ARRAY);
-
-                if (usingVBOs) {
-                    gl.glBindBuffer(GL.GL_ARRAY_BUFFER,
-                                    mVBO_For_ResuableTileVertices);
-                    gl.glBufferSubData(GL.GL_ARRAY_BUFFER, 0,
-                                       mOutstandingGlyphsVerticesPipeline * kSizeInBytes_OneVertices_VertexData,
-                                       mVertCoords); // upload only the new stuff
-                    gl.glVertexPointer(3, GL.GL_FLOAT, 0, 0);
-                } else {
-                    gl.glVertexPointer(3, GL.GL_FLOAT, 0, mVertCoords);
-                }
-
-                gl.glEnableClientState(GL.GL_TEXTURE_COORD_ARRAY);
-
-                if (usingVBOs) {
-                    gl.glBindBuffer(GL.GL_ARRAY_BUFFER,
-                                    mVBO_For_ResuableTileTexCoords);
-                    gl.glBufferSubData(GL.GL_ARRAY_BUFFER, 0,
-                                       mOutstandingGlyphsVerticesPipeline * kSizeInBytes_OneVertices_TexData,
-                                       mTexCoords); // upload only the new stuff
-                    gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, 0);
-                } else {
-                    gl.glTexCoordPointer(2, GL.GL_FLOAT, 0, mTexCoords);
-                }
-
-                gl.glDrawArrays(GL.GL_QUADS, 0,
-                                mOutstandingGlyphsVerticesPipeline);
-
-                mVertCoords.rewind();
-                mTexCoords.rewind();
-                mOutstandingGlyphsVerticesPipeline = 0;
-            }
-        }
-
-        private void drawIMMEDIATE() {
-            if (mOutstandingGlyphsVerticesPipeline > 0) {
-                TextureRenderer renderer = getBackingStore();
-                Texture texture = renderer.getTexture(); // triggers texture uploads.  Maybe this should be more obvious?
-
-                GL gl = GLU.getCurrentGL();
-                gl.glBegin(GL.GL_QUADS);
-
-                try {
-                    int numberOfQuads = mOutstandingGlyphsVerticesPipeline / 4;
-                    mVertCoords.rewind();
-                    mTexCoords.rewind();
-
-                    for (int i = 0; i < numberOfQuads; i++) {
-                        gl.glTexCoord2f(mTexCoords.get(), mTexCoords.get());
-                        gl.glVertex3f(mVertCoords.get(), mVertCoords.get(),
-                                      mVertCoords.get());
-
-                        gl.glTexCoord2f(mTexCoords.get(), mTexCoords.get());
-                        gl.glVertex3f(mVertCoords.get(), mVertCoords.get(),
-                                      mVertCoords.get());
-
-                        gl.glTexCoord2f(mTexCoords.get(), mTexCoords.get());
-                        gl.glVertex3f(mVertCoords.get(), mVertCoords.get(),
-                                      mVertCoords.get());
-
-                        gl.glTexCoord2f(mTexCoords.get(), mTexCoords.get());
-                        gl.glVertex3f(mVertCoords.get(), mVertCoords.get(),
-                                      mVertCoords.get());
-                    }
-                } catch (Exception e) {
-                    e.printStackTrace();
-                } finally {
-                    gl.glEnd();
-                    mVertCoords.rewind();
-                    mTexCoords.rewind();
-                    mOutstandingGlyphsVerticesPipeline = 0;
-                }
-            }
-        }
-    }
-
-    class DebugListener implements GLEventListener {
-        private GLU glu = new GLU();
-        private Frame frame;
-
-        DebugListener(Frame frame) {
-            this.frame = frame;
-        }
-
-        public void display(GLAutoDrawable drawable) {
-            GL gl = drawable.getGL();
-            gl.glClear(GL.GL_DEPTH_BUFFER_BIT | GL.GL_COLOR_BUFFER_BIT);
-
-            if (packer == null) {
-                return;
-            }
-
-            TextureRenderer rend = getBackingStore();
-            final int w = rend.getWidth();
-            final int h = rend.getHeight();
-            rend.beginOrthoRendering(w, h);
-            rend.drawOrthoRect(0, 0);
-            rend.endOrthoRendering();
-
-            if ((frame.getWidth() != w) || (frame.getHeight() != h)) {
-                EventQueue.invokeLater(new Runnable() {
-                        public void run() {
-                            frame.setSize(w, h);
-                        }
-                    });
-            }
-        }
-
-        // Unused methods
-        public void init(GLAutoDrawable drawable) {
-        }
-
-        public void reshape(GLAutoDrawable drawable, int x, int y, int width,
-                            int height) {
-        }
-
-        public void displayChanged(GLAutoDrawable drawable,
-                                   boolean modeChanged, boolean deviceChanged) {
-        }
-    }
-
-    /**
-     * Sets whether vertex arrays are being used internally for
-     * rendering, or whether text is rendered using the OpenGL
-     * immediate mode commands. This is provided as a concession for
-     * certain graphics cards which have poor vertex array
-     * performance. Defaults to true.
-     */
-    public void setUseVertexArrays(boolean useVertexArrays) {
-        this.useVertexArrays = useVertexArrays;
-    }
-
-    /**
-     * Indicates whether vertex arrays are being used internally for
-     * rendering, or whether text is rendered using the OpenGL
-     * immediate mode commands. Defaults to true.
-     */
-    public boolean getUseVertexArrays() {
-        return useVertexArrays;
-    }
-
-    /**
-     * Sets whether smoothing (i.e., GL_LINEAR filtering) is enabled
-     * in the backing TextureRenderer of this TextRenderer. A few
-     * graphics cards do not behave well when this is enabled,
-     * resulting in fuzzy text. Defaults to true.
-     */
-    public void setSmoothing(boolean smoothing) {
-        this.smoothing = smoothing;
-        getBackingStore().setSmoothing(smoothing);
-    }
-
-    /**
-     * Indicates whether smoothing is enabled in the backing
-     * TextureRenderer of this TextRenderer. A few graphics cards do
-     * not behave well when this is enabled, resulting in fuzzy text.
-     * Defaults to true.
-     */
-    public boolean getSmoothing() {
-        return smoothing;
-    }
-
-    private boolean is15Available(GL gl) {
-        if (!checkFor_isExtensionAvailable_GL_VERSION_1_5) {
-            isExtensionAvailable_GL_VERSION_1_5 = gl.isExtensionAvailable("GL_VERSION_1_5");
-            checkFor_isExtensionAvailable_GL_VERSION_1_5 = true;
-        }
-        return isExtensionAvailable_GL_VERSION_1_5;
-    }
-}
diff --git a/src/classes/com/sun/opengl/util/j2d/TextureRenderer.java b/src/classes/com/sun/opengl/util/j2d/TextureRenderer.java
deleted file mode 100755
index 4ca3d03e0..000000000
--- a/src/classes/com/sun/opengl/util/j2d/TextureRenderer.java
+++ /dev/null
@@ -1,695 +0,0 @@
-/*
- * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- * - Redistribution of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * 
- * - Redistribution 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 Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- * 
- * This software is provided "AS IS," without a warranty of any kind. ALL
- * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
- * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
- * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
- * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
- * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
- * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
- * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
- * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
- * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- * 
- * You acknowledge that this software is not designed or intended for use
- * in the design, construction, operation or maintenance of any nuclear
- * facility.
- * 
- * Sun gratefully acknowledges that this software was originally authored
- * and developed by Kenneth Bradley Russell and Christopher John Kline.
- */
-
-package com.sun.opengl.util.j2d;
-
-import java.awt.Color;
-import java.awt.Dimension;
-import java.awt.Graphics2D;
-import java.awt.Image;
-import java.awt.Rectangle;
-import java.awt.image.*;
-
-import javax.media.opengl.*;
-import javax.media.opengl.glu.*;
-import com.sun.opengl.util.texture.*;
-
-/** Provides the ability to render into an OpenGL {@link
-    com.sun.opengl.util.texture.Texture Texture} using the Java 2D
-    APIs. This renderer class uses an internal Java 2D image (of
-    unspecified type) for its backing store and flushes portions of
-    that image to an OpenGL texture on demand. The resulting OpenGL
-    texture can then be mapped on to a polygon for display. */
-
-public class TextureRenderer {
-  // For now, we supply only a BufferedImage back-end for this
-  // renderer. In theory we could use the Java 2D/JOGL bridge to fully
-  // accelerate the rendering paths, but there are restrictions on
-  // what work can be done where; for example, Graphics2D-related work
-  // must not be done on the Queue Flusher Thread, but JOGL's
-  // OpenGL-related work must be. This implies that the user's code
-  // would need to be split up into multiple callbacks run from the
-  // appropriate threads, which would be somewhat unfortunate.
-
-  // Whether we have an alpha channel in the (RGB/A) backing store
-  private boolean alpha;
-
-  // Whether we're using only a GL_INTENSITY backing store
-  private boolean intensity;
-
-  // Whether we're attempting to use automatic mipmap generation support
-  private boolean mipmap;
-
-  // Whether smoothing is enabled for the OpenGL texture (switching
-  // between GL_LINEAR and GL_NEAREST filtering)
-  private boolean smoothing = true;
-  private boolean smoothingChanged;
-
-  // The backing store itself
-  private BufferedImage image;
-
-  private Texture texture;
-  private TextureData textureData;
-  private boolean mustReallocateTexture;
-  private Rectangle dirtyRegion;
-
-  private GLU glu = new GLU();
-
-  // Current color
-  private float r = 1.0f;
-  private float g = 1.0f;
-  private float b = 1.0f;
-  private float a = 1.0f;
-
-  /** Creates a new renderer with backing store of the specified width
-      and height. If <CODE>alpha</CODE> is true, allocates an alpha
-      channel in the backing store image. No mipmap support is
-      requested.
-
-      @param width the width of the texture to render into
-      @param height the height of the texture to render into
-      @param alpha whether to allocate an alpha channel for the texture
-  */
-  public TextureRenderer(int width, int height, boolean alpha) {
-    this(width, height, alpha, false);
-  }
-
-  /** Creates a new renderer with backing store of the specified width
-      and height. If <CODE>alpha</CODE> is true, allocates an alpha channel in the
-      backing store image. If <CODE>mipmap</CODE> is true, attempts to use OpenGL's
-      automatic mipmap generation for better smoothing when rendering
-      the TextureRenderer's contents at a distance.
-
-      @param width the width of the texture to render into
-      @param height the height of the texture to render into
-      @param alpha whether to allocate an alpha channel for the texture
-      @param mipmap whether to attempt use of automatic mipmap generation
-  */
-  public TextureRenderer(int width, int height, boolean alpha, boolean mipmap) {
-    this(width, height, alpha, false, mipmap);
-  }
-
-  // Internal constructor to avoid confusion since alpha only makes
-  // sense when intensity is not set
-  private TextureRenderer(int width, int height, boolean alpha, boolean intensity, boolean mipmap) {
-    this.alpha = alpha;
-    this.intensity = intensity;
-    this.mipmap = mipmap;
-    init(width, height);
-  }
-
-  /** Creates a new renderer with a special kind of backing store
-      which acts only as an alpha channel. No mipmap support is
-      requested. Internally, this associates a GL_INTENSITY OpenGL
-      texture with the backing store. */
-  public static TextureRenderer createAlphaOnlyRenderer(int width, int height) {
-    return createAlphaOnlyRenderer(width, height, false);
-  }
-
-  /** Creates a new renderer with a special kind of backing store
-      which acts only as an alpha channel. If <CODE>mipmap</CODE> is
-      true, attempts to use OpenGL's automatic mipmap generation for
-      better smoothing when rendering the TextureRenderer's contents
-      at a distance. Internally, this associates a GL_INTENSITY OpenGL
-      texture with the backing store. */
-  public static TextureRenderer createAlphaOnlyRenderer(int width, int height, boolean mipmap) {
-    return new TextureRenderer(width, height, false, true, mipmap);
-  }
-
-  /** Returns the width of the backing store of this renderer.
-
-      @return the width of the backing store of this renderer
-  */
-  public int getWidth() {
-    return image.getWidth();
-  }
-
-  /** Returns the height of the backing store of this renderer.
-
-      @return the height of the backing store of this renderer
-  */
-  public int getHeight() {
-    return image.getHeight();
-  }
-
-  /** Returns the size of the backing store of this renderer in a
-      newly-allocated {@link java.awt.Dimension Dimension} object.
-
-      @return the size of the backing store of this renderer
-  */
-  public Dimension getSize() {
-    return getSize(null);
-  }
-
-  /** Returns the size of the backing store of this renderer. Uses the
-      {@link java.awt.Dimension Dimension} object if one is supplied,
-      or allocates a new one if null is passed.
-
-      @param d a {@link java.awt.Dimension Dimension} object in which
-        to store the results, or null to allocate a new one
-
-      @return the size of the backing store of this renderer
-  */
-  public Dimension getSize(Dimension d) {
-    if (d == null)
-      d = new Dimension();
-    d.setSize(image.getWidth(), image.getHeight());
-    return d;
-  }
-
-  /** Sets the size of the backing store of this renderer. This may
-      cause the OpenGL texture object associated with this renderer to
-      be invalidated; it is not recommended to cache this texture
-      object outside this class but to instead call {@link #getTexture
-      getTexture} when it is needed.
-
-      @param width the new width of the backing store of this renderer
-      @param height the new height of the backing store of this renderer
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void setSize(int width, int height) throws GLException {
-    init(width, height);
-  }
-
-  /** Sets the size of the backing store of this renderer. This may
-      cause the OpenGL texture object associated with this renderer to
-      be invalidated.
-
-      @param d the new size of the backing store of this renderer
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void setSize(Dimension d) throws GLException {
-    setSize(d.width, d.height);
-  }
-
-  /** Sets whether smoothing is enabled for the OpenGL texture; if so,
-      uses GL_LINEAR interpolation for the minification and
-      magnification filters. Defaults to true. Changes to this setting
-      will not take effect until the next call to {@link
-      #beginOrthoRendering beginOrthoRendering}.
-
-      @param smoothing whether smoothing is enabled for the OpenGL texture
-  */
-  public void setSmoothing(boolean smoothing) {
-    this.smoothing = smoothing;
-    smoothingChanged = true;
-  }
-
-  /** Returns whether smoothing is enabled for the OpenGL texture; see
-      {@link #setSmoothing setSmoothing}. Defaults to true.
-
-      @return whether smoothing is enabled for the OpenGL texture
-  */
-  public boolean getSmoothing() {
-    return smoothing;
-  }
-
-  /** Creates a {@link java.awt.Graphics2D Graphics2D} instance for
-      rendering to the backing store of this renderer. The returned
-      object should be disposed of using the normal {@link
-      java.awt.Graphics#dispose() Graphics.dispose()} method once it
-      is no longer being used.
-
-      @return a new {@link java.awt.Graphics2D Graphics2D} object for
-        rendering into the backing store of this renderer
-  */
-  public Graphics2D createGraphics() {
-    return image.createGraphics();
-  }
-
-  /** Returns the underlying Java 2D {@link java.awt.Image Image}
-      being rendered into. */
-  public Image getImage() {
-    return image;
-  }
-
-  /** Marks the given region of the TextureRenderer as dirty. This
-      region, and any previously set dirty regions, will be
-      automatically synchronized with the underlying Texture during
-      the next {@link #getTexture getTexture} operation, at which
-      point the dirty region will be cleared. It is not necessary for
-      an OpenGL context to be current when this method is called.
-
-      @param x the x coordinate (in Java 2D coordinates -- relative to
-        upper left) of the region to update
-      @param y the y coordinate (in Java 2D coordinates -- relative to
-        upper left) of the region to update
-      @param width the width of the region to update
-      @param height the height of the region to update
-  */
-  public void markDirty(int x, int y, int width, int height) {
-    Rectangle curRegion = new Rectangle(x, y, width, height);
-    if (dirtyRegion == null) {
-      dirtyRegion = curRegion;
-    } else {
-      dirtyRegion.add(curRegion);
-    }
-  }
-
-  /** Returns the underlying OpenGL Texture object associated with
-      this renderer, synchronizing any dirty regions of the
-      TextureRenderer with the underlying OpenGL texture.
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public Texture getTexture() throws GLException {
-    if (dirtyRegion != null) {
-      sync(dirtyRegion.x, dirtyRegion.y, dirtyRegion.width, dirtyRegion.height);
-      dirtyRegion = null;
-    }
-
-    ensureTexture();
-    return texture;
-  }
-
-  /** Disposes all resources associated with this renderer. It is not
-      valid to use this renderer after calling this method.
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void dispose() throws GLException {
-    if (texture != null) {
-      texture.dispose();
-      texture = null;
-    }
-    if (image != null) {
-      image.flush();
-      image = null;
-    }
-  }
-
-  /** Convenience method which assists in rendering portions of the
-      OpenGL texture to the screen, if the application intends to draw
-      them as a flat overlay on to the screen. Pushes OpenGL state
-      bits (GL_ENABLE_BIT, GL_DEPTH_BUFFER_BIT and GL_TRANSFORM_BIT);
-      disables the depth test, back-face culling, and lighting;
-      enables the texture in this renderer; and sets up the viewing
-      matrices for orthographic rendering where the coordinates go
-      from (0, 0) at the lower left to (width, height) at the upper
-      right. Equivalent to beginOrthoRendering(width, height, true).
-      {@link #endOrthoRendering} must be used in conjunction with this
-      method to restore all OpenGL states.
-
-      @param width the width of the current on-screen OpenGL drawable
-      @param height the height of the current on-screen OpenGL drawable
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void beginOrthoRendering(int width, int height) throws GLException {
-    beginOrthoRendering(width, height, true);
-  }
-
-  /** Convenience method which assists in rendering portions of the
-      OpenGL texture to the screen, if the application intends to draw
-      them as a flat overlay on to the screen. Pushes OpenGL state
-      bits (GL_ENABLE_BIT, GL_DEPTH_BUFFER_BIT and GL_TRANSFORM_BIT);
-      disables the depth test (if the "disableDepthTest" argument is
-      true), back-face culling, and lighting; enables the texture in
-      this renderer; and sets up the viewing matrices for orthographic
-      rendering where the coordinates go from (0, 0) at the lower left
-      to (width, height) at the upper right. {@link
-      #endOrthoRendering} must be used in conjunction with this method
-      to restore all OpenGL states.
-
-      @param width the width of the current on-screen OpenGL drawable
-      @param height the height of the current on-screen OpenGL drawable
-      @param disableDepthTest whether the depth test should be disabled
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void beginOrthoRendering(int width, int height, boolean disableDepthTest) throws GLException {
-    beginRendering(true, width, height, disableDepthTest);
-  }
-
-  /** Convenience method which assists in rendering portions of the
-      OpenGL texture to the screen as 2D quads in 3D space. Pushes
-      OpenGL state (GL_ENABLE_BIT); disables lighting; and enables the
-      texture in this renderer. Unlike {@link #beginOrthoRendering
-      beginOrthoRendering}, does not modify the depth test, back-face
-      culling, lighting, or the modelview or projection matrices. The
-      user is responsible for setting up the view matrices for correct
-      results of {@link #draw3DRect draw3DRect}. {@link
-      #end3DRendering} must be used in conjunction with this method to
-      restore all OpenGL states.
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void begin3DRendering() throws GLException {
-    beginRendering(false, 0, 0, false);
-  }
-
-  /** Changes the color of the polygons, and therefore the drawn
-      images, this TextureRenderer produces. Use of this method is
-      optional. The TextureRenderer uses the GL_MODULATE texture
-      environment mode, which causes the portions of the rendered
-      texture to be multiplied by the color of the rendered
-      polygons. The polygon color can be varied to achieve effects
-      like tinting of the overall output or fading in and out by
-      changing the alpha of the color. <P>
-
-      Each component ranges from 0.0f - 1.0f. The alpha component, if
-      used, does not need to be premultiplied into the color channels
-      as described in the documentation for {@link
-      com.sun.opengl.util.texture.Texture Texture}, although
-      premultiplied colors are used internally. The default color is
-      opaque white.
-
-      @param r the red component of the new color
-      @param g the green component of the new color
-      @param b the blue component of the new color
-      @param a the alpha component of the new color, 0.0f = completely
-        transparent, 1.0f = completely opaque
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void setColor(float r, float g, float b, float a) throws GLException {
-    GL gl = GLU.getCurrentGL();
-    this.r = r * a;
-    this.g = g * a;
-    this.b = b * a;
-    this.a = a;
-
-    gl.glColor4f(this.r, this.g, this.b, this.a);
-  }  
-
-  private float[] compArray;
-  /** Changes the current color of this TextureRenderer to the
-      supplied one. The default color is opaque white. See {@link
-      #setColor(float,float,float,float) setColor} for more details.
-
-      @param color the new color to use for rendering
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void setColor(Color color) throws GLException {
-    // Get color's RGBA components as floats in the range [0,1].
-    if (compArray == null) {
-      compArray = new float[4];
-    }
-    color.getRGBComponents(compArray);
-    setColor(compArray[0], compArray[1], compArray[2], compArray[3]);
-  }
-
-  /** Draws an orthographically projected rectangle containing all of
-      the underlying texture to the specified location on the
-      screen. All (x, y) coordinates are specified relative to the
-      lower left corner of either the texture image or the current
-      OpenGL drawable. This method is equivalent to
-      <code>drawOrthoRect(screenx, screeny, 0, 0, getWidth(),
-      getHeight());</code>.
-
-      @param screenx the on-screen x coordinate at which to draw the rectangle
-      @param screeny the on-screen y coordinate (relative to lower left) at
-        which to draw the rectangle
-      
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void drawOrthoRect(int screenx, int screeny) throws GLException {
-    drawOrthoRect(screenx, screeny, 0, 0, getWidth(), getHeight());
-  }
-
-  /** Draws an orthographically projected rectangle of the underlying
-      texture to the specified location on the screen. All (x, y)
-      coordinates are specified relative to the lower left corner of
-      either the texture image or the current OpenGL drawable.
-
-      @param screenx the on-screen x coordinate at which to draw the rectangle
-      @param screeny the on-screen y coordinate (relative to lower left) at
-        which to draw the rectangle
-      @param texturex the x coordinate of the pixel in the texture of
-        the lower left portion of the rectangle to draw
-      @param texturey the y coordinate of the pixel in the texture
-        (relative to lower left) of the lower left portion of the
-        rectangle to draw
-      @param width the width of the rectangle to draw
-      @param height the height of the rectangle to draw
-      
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void drawOrthoRect(int screenx, int screeny,
-                            int texturex, int texturey,
-                            int width, int height) throws GLException {
-    draw3DRect(screenx, screeny, 0, texturex, texturey, width, height, 1);
-  }
-
-  /** Draws a rectangle of the underlying texture to the specified 3D
-      location. In the current coordinate system, the lower left
-      corner of the rectangle is placed at (x, y, z), and the upper
-      right corner is placed at (x + width * scaleFactor, y + height *
-      scaleFactor, z). The lower left corner of the sub-rectangle of
-      the texture is (texturex, texturey) and the upper right corner
-      is (texturex + width, texturey + height). For back-face culling
-      purposes, the rectangle is drawn with counterclockwise
-      orientation of the vertices when viewed from the front.
-
-      @param x the x coordinate at which to draw the rectangle
-      @param y the y coordinate at which to draw the rectangle
-      @param z the z coordinate at which to draw the rectangle
-      @param texturex the x coordinate of the pixel in the texture of
-        the lower left portion of the rectangle to draw
-      @param texturey the y coordinate of the pixel in the texture
-        (relative to lower left) of the lower left portion of the
-        rectangle to draw
-      @param width the width in texels of the rectangle to draw
-      @param height the height in texels of the rectangle to draw
-      @param scaleFactor the scale factor to apply (multiplicatively)
-        to the size of the drawn rectangle
-      
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void draw3DRect(float x, float y, float z,
-                         int texturex, int texturey,
-                         int width, int height,
-                         float scaleFactor) throws GLException {
-    GL gl = GLU.getCurrentGL();
-    Texture texture = getTexture();
-    TextureCoords coords = texture.getSubImageTexCoords(texturex, texturey,
-                                                        texturex + width,
-                                                        texturey + height);
-    gl.glBegin(GL.GL_QUADS);
-    gl.glTexCoord2f(coords.left(), coords.bottom());
-    gl.glVertex3f(x, y, z);
-    gl.glTexCoord2f(coords.right(), coords.bottom());
-    gl.glVertex3f(x + width * scaleFactor, y, z);
-    gl.glTexCoord2f(coords.right(), coords.top());
-    gl.glVertex3f(x + width * scaleFactor, y + height * scaleFactor, z);
-    gl.glTexCoord2f(coords.left(), coords.top());
-    gl.glVertex3f(x, y + height * scaleFactor, z);
-    gl.glEnd();
-  }
-
-  /** Convenience method which assists in rendering portions of the
-      OpenGL texture to the screen, if the application intends to draw
-      them as a flat overlay on to the screen. Must be used if {@link
-      #beginOrthoRendering} is used to set up the rendering stage for
-      this overlay. 
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void endOrthoRendering() throws GLException {
-    endRendering(true);
-  }
-
-  /** Convenience method which assists in rendering portions of the
-      OpenGL texture to the screen as 2D quads in 3D space. Must be
-      used if {@link #begin3DRendering} is used to set up the
-      rendering stage for this overlay.
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  public void end3DRendering() throws GLException {
-    endRendering(false);
-  }
-
-  /** Indicates whether automatic mipmap generation is in use for this
-      TextureRenderer. The result of this method may change from true
-      to false if it is discovered during allocation of the
-      TextureRenderer's backing store that automatic mipmap generation
-      is not supported at the OpenGL level. */
-  public boolean isUsingAutoMipmapGeneration() {
-    return mipmap;
-  }
-
-  //----------------------------------------------------------------------
-  // Internals only below this point
-  //
-
-  private void beginRendering(boolean ortho, int width, int height, boolean disableDepthTestForOrtho) {
-    GL gl = GLU.getCurrentGL();
-    int attribBits = 
-      GL.GL_ENABLE_BIT | GL.GL_TEXTURE_BIT | GL.GL_COLOR_BUFFER_BIT |
-      (ortho ? (GL.GL_DEPTH_BUFFER_BIT | GL.GL_TRANSFORM_BIT) : 0);
-    gl.glPushAttrib(attribBits);
-    gl.glDisable(GL.GL_LIGHTING);
-    if (ortho) {
-      if (disableDepthTestForOrtho) {
-        gl.glDisable(GL.GL_DEPTH_TEST);
-      }
-      gl.glDisable(GL.GL_CULL_FACE);
-      gl.glMatrixMode(GL.GL_PROJECTION);
-      gl.glPushMatrix();
-      gl.glLoadIdentity();
-      glu.gluOrtho2D(0, width, 0, height);
-      gl.glMatrixMode(GL.GL_MODELVIEW);
-      gl.glPushMatrix();
-      gl.glLoadIdentity();
-      gl.glMatrixMode(GL.GL_TEXTURE);
-      gl.glPushMatrix();
-      gl.glLoadIdentity();
-    }
-    gl.glEnable(GL.GL_BLEND);
-    gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE_MINUS_SRC_ALPHA);
-    Texture texture = getTexture();
-    texture.enable();
-    texture.bind();
-    gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_MODULATE);
-    // Change polygon color to last saved
-    gl.glColor4f(r, g, b, a);
-    if (smoothingChanged) {
-      smoothingChanged = false;
-      if (smoothing) {
-        texture.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
-        if (mipmap) {
-          texture.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR);
-        } else {
-          texture.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
-        }
-      } else {
-        texture.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
-        texture.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
-      }
-    }
-  }
-
-  private void endRendering(boolean ortho) {
-    GL gl = GLU.getCurrentGL();
-    Texture texture = getTexture();
-    texture.disable();
-    if (ortho) {
-      gl.glMatrixMode(GL.GL_PROJECTION);
-      gl.glPopMatrix();
-      gl.glMatrixMode(GL.GL_MODELVIEW);
-      gl.glPopMatrix();
-      gl.glMatrixMode(GL.GL_TEXTURE);
-      gl.glPopMatrix();
-    }
-    gl.glPopAttrib();
-  }
-
-  private void init(int width, int height) {
-    // Discard previous BufferedImage if any
-    if (image != null) {
-      image.flush();
-      image = null;
-    }
-
-    // Infer the internal format if not an intensity texture
-    int internalFormat = (intensity ? GL.GL_INTENSITY : 0);
-    int imageType = 
-      (intensity ? BufferedImage.TYPE_BYTE_GRAY :
-       (alpha ?  BufferedImage.TYPE_INT_ARGB_PRE : BufferedImage.TYPE_INT_RGB));
-    image = new BufferedImage(width, height, imageType);
-    // Always realllocate the TextureData associated with this
-    // BufferedImage; it's just a reference to the contents but we
-    // need it in order to update sub-regions of the underlying
-    // texture
-    textureData = new TextureData(internalFormat, 0, mipmap, image);
-    // For now, always reallocate the underlying OpenGL texture when
-    // the backing store size changes
-    mustReallocateTexture = true;
-  }
-
-  /** Synchronizes the specified region of the backing store down to
-      the underlying OpenGL texture. If {@link #markDirty markDirty}
-      is used instead to indicate the regions that are out of sync,
-      this method does not need to be called.
-
-      @param x the x coordinate (in Java 2D coordinates -- relative to
-        upper left) of the region to update
-      @param y the y coordinate (in Java 2D coordinates -- relative to
-        upper left) of the region to update
-      @param width the width of the region to update
-      @param height the height of the region to update
-
-      @throws GLException If an OpenGL context is not current when this method is called
-  */
-  private void sync(int x, int y, int width, int height) throws GLException {
-    // Force allocation if necessary
-    boolean canSkipUpdate = ensureTexture();
-
-    if (!canSkipUpdate) {
-      // Update specified region.
-      // NOTE that because BufferedImage-based TextureDatas now don't
-      // do anything to their contents, the coordinate systems for
-      // OpenGL and Java 2D actually line up correctly for
-      // updateSubImage calls, so we don't need to do any argument
-      // conversion here (i.e., flipping the Y coordinate).
-      texture.updateSubImage(textureData, 0, x, y, x, y, width, height);
-    }
-  }
-
-  // Returns true if the texture was newly allocated, false if not
-  private boolean ensureTexture() {
-    if (mustReallocateTexture) {
-      if (texture != null) {
-        texture.dispose();
-        texture = null;
-      }
-      mustReallocateTexture = false;
-    }
-
-    if (texture == null) {
-      texture = TextureIO.newTexture(textureData);
-      if (mipmap && !texture.isUsingAutoMipmapGeneration()) {
-        // Only try this once
-        texture.dispose();
-        mipmap = false;
-        textureData.setMipmap(false);
-        texture = TextureIO.newTexture(textureData);
-      }
-
-      if (!smoothing) {
-        // The TextureIO classes default to GL_LINEAR filtering
-        texture.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
-        texture.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
-      }
-      return true;
-    }
-
-    return false;
-  }
-}