propane 3.4.2-java → 3.8.0-java

data/src/main/java/processing/net/Client.java

@@ -37,7 +37,7 @@ import java.net.*;
    * goes wrong with the connection, for example the host is not there or is 
    * listening on a different port, an exception is thrown.
    * 
-   * ( end auto-generated )
+   * 
  * @webref net
  * @brief The client class is used to create client Objects which connect to a server to exchange data. 
  * @instanceName client any variable of type Client
@@ -108,7 +108,7 @@ public class Client implements Runnable {
       }
 
     } catch (IOException e) {
-      e.printStackTrace();
+
       dispose();
     }
   }
@@ -153,7 +153,7 @@ public class Client implements Runnable {
    * Disconnects from the server. Use to shut the connection when you're 
    * finished with the Client.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @brief Disconnects from the server
    * @usage application
@@ -194,7 +194,7 @@ public class Client implements Runnable {
         input = null;
       }
     } catch (Exception e) {
-      e.printStackTrace();
+
     }
 
     try {
@@ -203,7 +203,7 @@ public class Client implements Runnable {
         output = null;
       }
     } catch (Exception e) {
-      e.printStackTrace();
+
     }
     
     try {
@@ -212,7 +212,7 @@ public class Client implements Runnable {
         socket = null;
       }
     } catch (Exception e) {
-      e.printStackTrace();
+
     }
   }
 
@@ -299,7 +299,7 @@ public class Client implements Runnable {
         }
       } catch (IOException e) {
         //errorMessage("run", e);
-        e.printStackTrace();
+  
       }
     }
   }
@@ -311,7 +311,7 @@ public class Client implements Runnable {
    * Returns true if this client is still active and hasn't run
    * into any trouble.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @brief Returns true if this client is still active
    * @usage application
@@ -326,7 +326,7 @@ public class Client implements Runnable {
    * 
    * Returns the IP address of the computer to which the Client is attached.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @usage application
    * @brief Returns the IP address of the machine as a String
@@ -345,7 +345,7 @@ public class Client implements Runnable {
    * Returns the number of bytes available. When any client has bytes 
    * available from the server, it returns the number of bytes.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @usage application
    * @brief Returns the number of bytes in the buffer waiting to be read
@@ -362,7 +362,7 @@ public class Client implements Runnable {
    * 
    * Empty the buffer, removes all the data stored there.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @usage application
    * @brief Clears the buffer
@@ -382,7 +382,7 @@ public class Client implements Runnable {
    * the buffer. Returns -1 if there is no byte, although this should be 
    * avoided by first cheacking <b>available()</b> to see if any data is available.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @usage application
    * @brief Returns a value from the buffer
@@ -407,7 +407,7 @@ public class Client implements Runnable {
    * Returns the next byte in the buffer as a char. Returns -1 or 0xffff if 
    * nothing is there.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @usage application
    * @brief Returns the next byte in the buffer as a char
@@ -431,7 +431,7 @@ public class Client implements Runnable {
    * of bytes read. If more bytes are available than can fit into the 
    * <b>byteBuffer</b>, only those that fit are read.
    * 
-   * ( end auto-generated )
+   * 
    * <h3>Advanced</h3>
    * Return a byte array of anything that's in the serial buffer.
    * Not particularly memory/speed efficient, because it creates
@@ -531,7 +531,7 @@ public class Client implements Runnable {
    * not large enough, -1 is returned and an error is printed to the message 
    * area. If nothing is in the buffer, 0 is returned.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @usage application
    * @brief Reads from the buffer of bytes up to and including a particular character
@@ -623,7 +623,7 @@ public class Client implements Runnable {
    * representation of your choice (i.e. UTF8 or two-byte Unicode data), and 
    * send it as a byte array.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @usage application
    * @brief Returns the buffer as a String
@@ -641,7 +641,7 @@ public class Client implements Runnable {
    * Combination of <b>readBytesUntil()</b> and <b>readString()</b>. Returns 
    * <b>null</b> if it doesn't find what you're looking for.
    * 
-   * ( end auto-generated )
+   * 
    * <h3>Advanced</h3>
    * <p/>
    * If you want to move Unicode data, you can first convert the
@@ -665,7 +665,7 @@ public class Client implements Runnable {
    * 
    * Writes data to a server specified when constructing the client.
    * 
-   * ( end auto-generated )
+   * 
    * @webref client:client
    * @usage application
    * @brief  	Writes bytes, chars, ints, bytes[], Strings
@@ -681,7 +681,7 @@ public class Client implements Runnable {
       //e.printStackTrace();
       //dispose();
       //disconnect(e);
-      e.printStackTrace();
+
       stop();
     }
   }
@@ -696,7 +696,7 @@ public class Client implements Runnable {
       //errorMessage("write", e);
       //e.printStackTrace();
       //disconnect(e);
-      e.printStackTrace();
+
       stop();
     }
   }

data/src/main/java/processing/net/Server.java

@@ -42,7 +42,7 @@ import java.net.*;
  * commonly used so be sure to not select one of these. For example, web 
  * servers usually use port 80 and POP mail uses port 110.
  * 
- * ( end auto-generated )
+ * 
  * @webref net
  * @usage application
  * @brief The server class is used to create server objects which send and receives data to and from its associated clients (other programs connected to it). 
@@ -119,7 +119,7 @@ public class Server implements Runnable {
    * 
    * Disconnect a particular client.
    * 
-   * ( end auto-generated )
+   * 
    * @brief Disconnect a particular client.
    * @webref server:server
    * @param client the client to disconnect
@@ -191,7 +191,7 @@ public class Server implements Runnable {
    * Returns true if this server is still active and hasn't run
    * into any trouble.
    * 
-   * ( end auto-generated )
+   * 
    * @webref server:server
    * @brief Return true if this server is still active.
    */
@@ -204,7 +204,7 @@ public class Server implements Runnable {
     try {
       return InetAddress.getLocalHost().getHostAddress();
     } catch (UnknownHostException e) {
-      e.printStackTrace();
+
       return null;
     }
   }
@@ -220,7 +220,7 @@ public class Server implements Runnable {
    * 
    * Returns the next client in line with a new message.
    * 
-   * ( end auto-generated )
+   * 
    * @brief Returns the next client in line with a new message.
    * @webref server
    * @usage application
@@ -258,7 +258,7 @@ public class Server implements Runnable {
    * 
    * Disconnects all clients and stops the server.
    * 
-   * ( end auto-generated )
+   * 
    * <h3>Advanced</h3>
    * Use this to shut down the server if you finish using it while your applet 
    * is still running. Otherwise, it will be automatically be shut down by the 
@@ -290,7 +290,7 @@ public class Server implements Runnable {
         server = null;
       }
     } catch (IOException e) {
-      e.printStackTrace();
+
     }
   }
 
@@ -324,7 +324,7 @@ public class Server implements Runnable {
         thread = null;
       } catch (IOException e) {
         //errorMessage("run", e);
-        e.printStackTrace();
+  
         thread = null;
       }
     }
@@ -337,7 +337,7 @@ public class Server implements Runnable {
    * Writes a value to all the connected clients. It sends bytes out from the 
    * Server object.
    * 
-   * ( end auto-generated )
+   * 
    * @webref server
    * @brief Writes data to all connected clients
    * @param data data to write

data/src/main/java/processing/opengl/FontTexture.java

@@ -1,3 +1,5 @@
+/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
 /*
   Part of the Processing project - http://processing.org
 
@@ -18,7 +20,8 @@
   Public License along with this library; if not, write to the
   Free Software Foundation, Inc., 59 Temple Place, Suite 330,
   Boston, MA  02111-1307  USA
- */
+*/
+
 package processing.opengl;
 
 import processing.core.PApplet;
@@ -30,203 +33,216 @@ import processing.core.PImage;
 import java.util.HashMap;
 
 /**
- * All the infrastructure needed for optimized font rendering in OpenGL.
- * Basically, this special class is needed because fonts in Processing are
- * handled by a separate PImage for each glyph. For performance reasons, all
- * these glyphs should be stored in a single OpenGL texture (otherwise,
- * rendering a string of text would involve binding and un-binding several
- * textures. PFontTexture manages the correspondence between individual glyphs
- * and the large OpenGL texture containing them. Also, in the case that the font
- * size is very large, one single OpenGL texture might not be enough to store
- * all the glyphs, so PFontTexture also takes care of spreading a single font
+ * All the infrastructure needed for optimized font rendering
+ * in OpenGL. Basically, this special class is needed because
+ * fonts in Processing are handled by a separate PImage for each
+ * glyph. For performance reasons, all these glyphs should be
+ * stored in a single OpenGL texture (otherwise, rendering a
+ * string of text would involve binding and un-binding several
+ * textures.
+ * PFontTexture manages the correspondence between individual
+ * glyphs and the large OpenGL texture containing them. Also,
+ * in the case that the font size is very large, one single
+ * OpenGL texture might not be enough to store all the glyphs,
+ * so PFontTexture also takes care of spreading a single font
  * over several textures.
- *
  * @author Andres Colubri
  */
 class FontTexture implements PConstants {
+  protected PGL pgl;
+  protected boolean is3D;
 
-    protected PGL pgl;
-    protected boolean is3D;
-
-    protected int minSize;
-    protected int maxSize;
-    protected int offsetX;
-    protected int offsetY;
-    protected int lineHeight;
-    protected Texture[] textures = null;
-    protected PImage[] images = null;
-    protected int lastTex;
-    protected TextureInfo[] glyphTexinfos;
-    protected HashMap<PFont.Glyph, TextureInfo> texinfoMap;
-
-    public FontTexture(PGraphicsOpenGL pg, PFont font, boolean is3D) {
-        pgl = pg.pgl;
-        this.is3D = is3D;
-
-        initTexture(pg, font);
-    }
+  protected int minSize;
+  protected int maxSize;
+  protected int offsetX;
+  protected int offsetY;
+  protected int lineHeight;
+  protected Texture[] textures = null;
+  protected PImage[] images = null;
+  protected int lastTex;
+  protected TextureInfo[] glyphTexinfos;
+  protected HashMap<PFont.Glyph, TextureInfo> texinfoMap;
 
-    protected void allocate() {
-        // Nothing to do here: the font textures will allocate
-        // themselves.
-    }
+  public FontTexture(PGraphicsOpenGL pg, PFont font, boolean is3D) {
+    pgl = pg.pgl;
+    this.is3D = is3D;
 
-    protected void dispose() {
-      for (Texture texture : textures) {
-        texture.dispose();
-      }
-    }
+    initTexture(pg, font);
+  }
 
-    protected void initTexture(PGraphicsOpenGL pg, PFont font) {
-        lastTex = -1;
 
-        int spow = PGL.nextPowerOfTwo(font.getSize());
-        minSize = PApplet.min(PGraphicsOpenGL.maxTextureSize,
-                PApplet.max(PGL.MIN_FONT_TEX_SIZE, spow));
-        maxSize = PApplet.min(PGraphicsOpenGL.maxTextureSize,
-                PApplet.max(PGL.MAX_FONT_TEX_SIZE, 2 * spow));
+  protected void allocate() {
+    // Nothing to do here: the font textures will allocate
+    // themselves.
+  }
 
-        if (maxSize < spow) {
-            PGraphics.showWarning("The font size is too large to be properly "
-                    + "displayed with OpenGL");
-        }
 
-        addTexture(pg);
+  protected void dispose() {
+    for (Texture texture : textures) {
+      texture.dispose();
+    }
+  }
 
-        offsetX = 0;
-        offsetY = 0;
-        lineHeight = 0;
 
-        texinfoMap = new HashMap<>();
-        glyphTexinfos = new TextureInfo[font.getGlyphCount()];
-        addAllGlyphsToTexture(pg, font);
+  protected void initTexture(PGraphicsOpenGL pg, PFont font) {
+    lastTex = -1;
+
+    int spow = PGL.nextPowerOfTwo(font.getSize());
+    minSize = PApplet.min(PGraphicsOpenGL.maxTextureSize,
+                          PApplet.max(PGL.MIN_FONT_TEX_SIZE, spow));
+    maxSize = PApplet.min(PGraphicsOpenGL.maxTextureSize,
+                          PApplet.max(PGL.MAX_FONT_TEX_SIZE, 2 * spow));
+
+    if (maxSize < spow) {
+      PGraphics.showWarning("The font size is too large to be properly " +
+                            "displayed with OpenGL");
     }
 
-    public boolean addTexture(PGraphicsOpenGL pg) {
-        int w, h;
-        boolean resize;
-
-        w = maxSize;
-        if (-1 < lastTex && textures[lastTex].glHeight < maxSize) {
-            // The height of the current texture is less than the maximum, this
-            // means we can replace it with a larger texture.
-            h = PApplet.min(2 * textures[lastTex].glHeight, maxSize);
-            resize = true;
-        } else {
-            h = minSize;
-            resize = false;
-        }
+    addTexture(pg);
 
-        Texture tex;
-        if (is3D) {
-            // Bilinear sampling ensures that the texture doesn't look pixelated
-            // either when it is magnified or minified...
-            tex = new Texture(pg, w, h,
-                    new Texture.Parameters(ARGB, Texture.BILINEAR, false));
-        } else {
-            // ...however, the effect of bilinear sampling is to add some blurriness
-            // to the text in its original size. In 2D, we assume that text will be
-            // shown at its original size, so linear sampling is chosen instead (which
-            // only affects minimized text).
-            tex = new Texture(pg, w, h,
-                    new Texture.Parameters(ARGB, Texture.LINEAR, false));
-        }
+    offsetX = 0;
+    offsetY = 0;
+    lineHeight = 0;
+
+    texinfoMap = new HashMap<>();
+    glyphTexinfos = new TextureInfo[font.getGlyphCount()];
+    addAllGlyphsToTexture(pg, font);
+  }
 
-        if (textures == null) {
-            textures = new Texture[1];
-            textures[0] = tex;
-            images = new PImage[1];
-            images[0] = pg.wrapTexture(tex);
-            lastTex = 0;
-        } else if (resize) {
-            // Replacing old smaller texture with larger one.
-            // But first we must copy the contents of the older
-            // texture into the new one.
-            Texture tex0 = textures[lastTex];
-            tex.put(tex0);
-            textures[lastTex] = tex;
-
-            pg.setCache(images[lastTex], tex);
-            images[lastTex].width = tex.width;
-            images[lastTex].height = tex.height;
-        } else {
-            // Adding new texture to the list.
-            lastTex = textures.length;
-            Texture[] tempTex = new Texture[lastTex + 1];
-            PApplet.arrayCopy(textures, tempTex, textures.length);
-            tempTex[lastTex] = tex;
-            textures = tempTex;
-
-            PImage[] tempImg = new PImage[textures.length];
-            PApplet.arrayCopy(images, tempImg, images.length);
-            tempImg[lastTex] = pg.wrapTexture(tex);
-            images = tempImg;
-        }
 
-        // Make sure that the current texture is bound.
-        tex.bind();
+  public boolean addTexture(PGraphicsOpenGL pg) {
+    int w, h;
+    boolean resize;
 
-        return resize;
+    w = maxSize;
+    if (-1 < lastTex && textures[lastTex].glHeight < maxSize) {
+      // The height of the current texture is less than the maximum, this
+      // means we can replace it with a larger texture.
+      h = PApplet.min(2 * textures[lastTex].glHeight, maxSize);
+      resize = true;
+    } else {
+      h = minSize;
+      resize = false;
     }
 
-    public void begin() {
+    Texture tex;
+    if (is3D) {
+      // Bilinear sampling ensures that the texture doesn't look pixelated
+      // either when it is magnified or minified...
+      tex = new Texture(pg, w, h,
+                        new Texture.Parameters(ARGB, Texture.BILINEAR, false));
+    } else {
+      // ...however, the effect of bilinear sampling is to add some blurriness
+      // to the text in its original size. In 2D, we assume that text will be
+      // shown at its original size, so linear sampling is chosen instead (which
+      // only affects minimized text).
+      tex = new Texture(pg, w, h,
+                        new Texture.Parameters(ARGB, Texture.LINEAR, false));
     }
 
-    public void end() {
-      for (Texture texture : textures) {
-        pgl.disableTexturing(texture.glTarget);
-      }
+    if (textures == null) {
+      textures = new Texture[1];
+      textures[0] = tex;
+      images = new PImage[1];
+      images[0] = pg.wrapTexture(tex);
+      lastTex = 0;
+    } else if (resize) {
+      // Replacing old smaller texture with larger one.
+      // But first we must copy the contents of the older
+      // texture into the new one.
+      Texture tex0 = textures[lastTex];
+      tex.put(tex0);
+      textures[lastTex] = tex;
+
+      pg.setCache(images[lastTex], tex);
+      images[lastTex].width = tex.width;
+      images[lastTex].height = tex.height;
+    } else {
+      // Adding new texture to the list.
+      lastTex = textures.length;
+      Texture[] tempTex = new Texture[lastTex + 1];
+      PApplet.arrayCopy(textures, tempTex, textures.length);
+      tempTex[lastTex] = tex;
+      textures = tempTex;
+
+      PImage[] tempImg = new PImage[textures.length];
+      PApplet.arrayCopy(images, tempImg, images.length);
+      tempImg[lastTex] = pg.wrapTexture(tex);
+      images = tempImg;
     }
 
-    public PImage getTexture(TextureInfo info) {
-        return images[info.texIndex];
+    // Make sure that the current texture is bound.
+    tex.bind();
+
+    return resize;
+  }
+
+
+  public void begin() {
+  }
+
+
+  public void end() {
+    for (Texture texture : textures) {
+      pgl.disableTexturing(texture.glTarget);
     }
+  }
 
-    // Add all the current glyphs to opengl texture.
-    public void addAllGlyphsToTexture(PGraphicsOpenGL pg, PFont font) {
-        // loop over current glyphs.
-        for (int i = 0; i < font.getGlyphCount(); i++) {
-            addToTexture(pg, i, font.getGlyph(i));
-        }
+
+  public PImage getTexture(TextureInfo info) {
+    return images[info.texIndex];
+  }
+
+
+  // Add all the current glyphs to opengl texture.
+  public void addAllGlyphsToTexture(PGraphicsOpenGL pg, PFont font) {
+    // loop over current glyphs.
+    for (int i = 0; i < font.getGlyphCount(); i++) {
+      addToTexture(pg, i, font.getGlyph(i));
     }
+  }
 
-    public void updateGlyphsTexCoords() {
-      // loop over current glyphs.
-      for (TextureInfo tinfo : glyphTexinfos) {
-        if (tinfo != null && tinfo.texIndex == lastTex) {
-          tinfo.updateUV();
-        }
+
+  public void updateGlyphsTexCoords() {
+    // loop over current glyphs.
+    for (TextureInfo tinfo : glyphTexinfos) {
+      if (tinfo != null && tinfo.texIndex == lastTex) {
+        tinfo.updateUV();
       }
     }
+  }
 
-    public TextureInfo getTexInfo(PFont.Glyph glyph) {
-        TextureInfo info = texinfoMap.get(glyph);
-        return info;
-    }
 
-    public TextureInfo addToTexture(PGraphicsOpenGL pg, PFont.Glyph glyph) {
-        int n = glyphTexinfos.length;
-        if (n == 0) {
-            glyphTexinfos = new TextureInfo[1];
-        }
-        addToTexture(pg, n, glyph);
-        return glyphTexinfos[n];
+  public TextureInfo getTexInfo(PFont.Glyph glyph) {
+    TextureInfo info = texinfoMap.get(glyph);
+    return info;
+  }
+
+
+  public TextureInfo addToTexture(PGraphicsOpenGL pg, PFont.Glyph glyph) {
+    int n = glyphTexinfos.length;
+    if (n == 0) {
+      glyphTexinfos = new TextureInfo[1];
     }
+    addToTexture(pg, n, glyph);
+    return glyphTexinfos[n];
+  }
+
 
-    public boolean contextIsOutdated() {
-        boolean outdated = false;
+  public boolean contextIsOutdated() {
+    boolean outdated = false;
+    for (Texture texture : textures) {
+      if (texture.contextIsOutdated()) {
+        outdated = true;
+      }
+    }
+    if (outdated) {
       for (Texture texture : textures) {
-        if (texture.contextIsOutdated()) {
-          outdated = true;
-        }
+        texture.dispose();
       }
-        if (outdated) {
-          for (Texture texture : textures) {
-            texture.dispose();
-          }
-        }
-        return outdated;
     }
+    return outdated;
+  }
 
 //  public void draw() {
 //    Texture tex = textures[lastTex];
@@ -234,125 +250,129 @@ class FontTexture implements PConstants {
 //                    tex.glWidth, tex.glHeight,
 //                    0, 0, tex.glWidth, tex.glHeight);
 //  }
-    // Adds this glyph to the opengl texture in PFont.
-    protected void addToTexture(PGraphicsOpenGL pg, int idx, PFont.Glyph glyph) {
-        // We add one pixel to avoid issues when sampling the font texture at
-        // fractional screen positions. I.e.: the pixel on the screen only contains
-        // half of the font rectangle, so it would sample half of the color from the
-        // glyph area in the texture, and the other half from the contiguous pixel.
-        // If the later contains a portion of the neighbor glyph and the former
-        // doesn't, this would result in a shaded pixel when the correct output is
-        // blank. This is a consequence of putting all the glyphs in a common
-        // texture with bilinear sampling.
-        int w = 1 + glyph.width + 1;
-        int h = 1 + glyph.height + 1;
-
-        // Converting the pixels array from the PImage into a valid RGBA array for
-        // OpenGL.
-        int[] rgba = new int[w * h];
-        int t = 0;
-        int p = 0;
-        if (PGL.BIG_ENDIAN) {
-            java.util.Arrays.fill(rgba, 0, w, 0xFFFFFF00); // Set the first row to blank pixels.
-            t = w;
-            for (int y = 0; y < glyph.height; y++) {
-                rgba[t++] = 0xFFFFFF00; // Set the leftmost pixel in this row as blank
-                for (int x = 0; x < glyph.width; x++) {
-                    rgba[t++] = 0xFFFFFF00 | glyph.image.pixels[p++];
-                }
-                rgba[t++] = 0xFFFFFF00; // Set the rightmost pixel in this row as blank
-            }
-            java.util.Arrays.fill(rgba, (h - 1) * w, h * w, 0xFFFFFF00); // Set the last row to blank pixels.
-        } else {
-            java.util.Arrays.fill(rgba, 0, w, 0x00FFFFFF); // Set the first row to blank pixels.
-            t = w;
-            for (int y = 0; y < glyph.height; y++) {
-                rgba[t++] = 0x00FFFFFF; // Set the leftmost pixel in this row as blank
-                for (int x = 0; x < glyph.width; x++) {
-                    rgba[t++] = (glyph.image.pixels[p++] << 24) | 0x00FFFFFF;
-                }
-                rgba[t++] = 0x00FFFFFF; // Set the rightmost pixel in this row as blank
-            }
-            java.util.Arrays.fill(rgba, (h - 1) * w, h * w, 0x00FFFFFF); // Set the last row to blank pixels.
-        }
 
-        // Is there room for this glyph in the current line?
-        if (offsetX + w > textures[lastTex].glWidth) {
-            // No room, go to the next line:
-            offsetX = 0;
-            offsetY += lineHeight;
+
+  // Adds this glyph to the opengl texture in PFont.
+  protected void addToTexture(PGraphicsOpenGL pg, int idx, PFont.Glyph glyph) {
+    // We add one pixel to avoid issues when sampling the font texture at
+    // fractional screen positions. I.e.: the pixel on the screen only contains
+    // half of the font rectangle, so it would sample half of the color from the
+    // glyph area in the texture, and the other half from the contiguous pixel.
+    // If the later contains a portion of the neighbor glyph and the former
+    // doesn't, this would result in a shaded pixel when the correct output is
+    // blank. This is a consequence of putting all the glyphs in a common
+    // texture with bilinear sampling.
+    int w = 1 + glyph.width + 1;
+    int h = 1 + glyph.height + 1;
+
+    // Converting the pixels array from the PImage into a valid RGBA array for
+    // OpenGL.
+    int[] rgba = new int[w * h];
+    int t = 0;
+    int p = 0;
+    if (PGL.BIG_ENDIAN)  {
+      java.util.Arrays.fill(rgba, 0, w, 0xFFFFFF00); // Set the first row to blank pixels.
+      t = w;
+      for (int y = 0; y < glyph.height; y++) {
+        rgba[t++] = 0xFFFFFF00; // Set the leftmost pixel in this row as blank
+        for (int x = 0; x < glyph.width; x++) {
+          rgba[t++] = 0xFFFFFF00 | glyph.image.pixels[p++];
         }
-        lineHeight = Math.max(lineHeight, h);
-
-        boolean resized = false;
-        if (offsetY + lineHeight > textures[lastTex].glHeight) {
-            // We run out of space in the current texture, so we add a new texture:
-            resized = addTexture(pg);
-            if (resized) {
-                // Because the current texture has been resized, we need to
-                // update the UV coordinates of all the glyphs associated to it:
-                updateGlyphsTexCoords();
-            } else {
-                // A new texture has been created. Reseting texture coordinates
-                // and line.
-                offsetX = 0;
-                offsetY = 0;
-                lineHeight = 0;
-            }
+        rgba[t++] = 0xFFFFFF00; // Set the rightmost pixel in this row as blank
+      }
+      java.util.Arrays.fill(rgba, (h - 1) * w, h * w, 0xFFFFFF00); // Set the last row to blank pixels.
+    } else {
+      java.util.Arrays.fill(rgba, 0, w, 0x00FFFFFF); // Set the first row to blank pixels.
+      t = w;
+      for (int y = 0; y < glyph.height; y++) {
+        rgba[t++] = 0x00FFFFFF; // Set the leftmost pixel in this row as blank
+        for (int x = 0; x < glyph.width; x++) {
+          rgba[t++] = (glyph.image.pixels[p++] << 24) | 0x00FFFFFF;
         }
+        rgba[t++] = 0x00FFFFFF; // Set the rightmost pixel in this row as blank
+      }
+      java.util.Arrays.fill(rgba, (h - 1) * w, h * w, 0x00FFFFFF); // Set the last row to blank pixels.
+    }
 
-        TextureInfo tinfo = new TextureInfo(lastTex, offsetX, offsetY, w, h, rgba);
-        offsetX += w;
+    // Is there room for this glyph in the current line?
+    if (offsetX + w > textures[lastTex].glWidth) {
+      // No room, go to the next line:
+      offsetX = 0;
+      offsetY += lineHeight;
+    }
+    lineHeight = Math.max(lineHeight, h);
+
+    boolean resized = false;
+    if (offsetY + lineHeight > textures[lastTex].glHeight) {
+      // We run out of space in the current texture, so we add a new texture:
+      resized = addTexture(pg);
+      if (resized) {
+        // Because the current texture has been resized, we need to
+        // update the UV coordinates of all the glyphs associated to it:
+        updateGlyphsTexCoords();
+      } else {
+        // A new texture has been created. Reseting texture coordinates
+        // and line.
+        offsetX = 0;
+        offsetY = 0;
+        lineHeight = 0;
+      }
+    }
 
-        if (idx == glyphTexinfos.length) {
-            TextureInfo[] temp = new TextureInfo[glyphTexinfos.length + 1];
-            System.arraycopy(glyphTexinfos, 0, temp, 0, glyphTexinfos.length);
-            glyphTexinfos = temp;
-        }
+    TextureInfo tinfo = new TextureInfo(lastTex, offsetX, offsetY, w, h, rgba);
+    offsetX += w;
 
-        glyphTexinfos[idx] = tinfo;
-        texinfoMap.put(glyph, tinfo);
+    if (idx == glyphTexinfos.length) {
+      TextureInfo[] temp = new TextureInfo[glyphTexinfos.length + 1];
+      System.arraycopy(glyphTexinfos, 0, temp, 0, glyphTexinfos.length);
+      glyphTexinfos = temp;
     }
 
-    class TextureInfo {
+    glyphTexinfos[idx] = tinfo;
+    texinfoMap.put(glyph, tinfo);
+  }
+
 
-        int texIndex;
-        int width;
-        int height;
-        int[] crop;
-        float u0, u1;
-        float v0, v1;
-        int[] pixels;
+  class TextureInfo {
+    int texIndex;
+    int width;
+    int height;
+    int[] crop;
+    float u0, u1;
+    float v0, v1;
+    int[] pixels;
 
-        TextureInfo(int tidx, int cropX, int cropY, int cropW, int cropH,
+    TextureInfo(int tidx, int cropX, int cropY, int cropW, int cropH,
                 int[] pix) {
-            texIndex = tidx;
-            crop = new int[4];
-            // The region of the texture corresponding to the glyph is surrounded by a
-            // 1-pixel wide border to avoid artifacts due to bilinear sampling. This
-            // is why the additions and subtractions to the crop values.
-            crop[0] = cropX + 1;
-            crop[1] = cropY + 1 + cropH - 2;
-            crop[2] = cropW - 2;
-            crop[3] = -cropH + 2;
-            pixels = pix;
-            updateUV();
-            updateTex();
-        }
+      texIndex = tidx;
+      crop = new int[4];
+      // The region of the texture corresponding to the glyph is surrounded by a
+      // 1-pixel wide border to avoid artifacts due to bilinear sampling. This
+      // is why the additions and subtractions to the crop values.
+      crop[0] = cropX + 1;
+      crop[1] = cropY + 1 + cropH - 2;
+      crop[2] = cropW - 2;
+      crop[3] = -cropH + 2;
+      pixels = pix;
+      updateUV();
+      updateTex();
+    }
 
-        void updateUV() {
-            width = textures[texIndex].glWidth;
-            height = textures[texIndex].glHeight;
 
-            u0 = (float) crop[0] / (float) width;
-            u1 = u0 + (float) crop[2] / (float) width;
-            v0 = (float) (crop[1] + crop[3]) / (float) height;
-            v1 = v0 - (float) crop[3] / (float) height;
-        }
+    void updateUV() {
+      width = textures[texIndex].glWidth;
+      height = textures[texIndex].glHeight;
 
-        void updateTex() {
-            textures[texIndex].setNative(pixels, crop[0] - 1, crop[1] + crop[3] - 1,
-                    crop[2] + 2, -crop[3] + 2);
-        }
+      u0 = (float)crop[0] / (float)width;
+      u1 = u0 + (float)crop[2] / (float)width;
+      v0 = (float)(crop[1] + crop[3]) / (float)height;
+      v1 = v0 - (float)crop[3] / (float)height;
+    }
+
+
+    void updateTex() {
+      textures[texIndex].setNative(pixels, crop[0] - 1, crop[1] + crop[3] - 1,
+                                           crop[2] + 2, -crop[3] + 2);
     }
+  }
 }