picrate 0.7.0-java → 0.8.0-java

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

@@ -1,6 +1,6 @@
 /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 
-/*
+ /*
   Part of the Processing project - http://processing.org
 
   Copyright (c) 2012-15 The Processing Foundation
@@ -20,8 +20,7 @@
   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;
@@ -33,22 +32,21 @@ 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;
 
@@ -70,32 +68,29 @@ class FontTexture implements PConstants {
     initTexture(pg, font);
   }
 
-
   protected void allocate() {
     // Nothing to do here: the font textures will allocate
     // themselves.
   }
 
-
   protected void dispose() {
-    for (int i = 0; i < textures.length; i++) {
-      textures[i].dispose();
+    for (Texture texture : textures) {
+      texture.dispose();
     }
   }
 
-
-  protected void initTexture(PGraphicsOpenGL pg, PFont font) {
+  protected final 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));
+      PApplet.max(PGL.MIN_FONT_TEX_SIZE, spow));
     maxSize = PApplet.min(PGraphicsOpenGL.maxTextureSize,
-                          PApplet.max(PGL.MAX_FONT_TEX_SIZE, 2 * spow));
+      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");
+      PGraphics.showWarning("The font size is too large to be properly "
+        + "displayed with OpenGL");
     }
 
     addTexture(pg);
@@ -104,12 +99,11 @@ class FontTexture implements PConstants {
     offsetY = 0;
     lineHeight = 0;
 
-    texinfoMap = new HashMap<PFont.Glyph, TextureInfo>();
+    texinfoMap = new HashMap<>();
     glyphTexinfos = new TextureInfo[font.getGlyphCount()];
     addAllGlyphsToTexture(pg, font);
   }
 
-
   public boolean addTexture(PGraphicsOpenGL pg) {
     int w, h;
     boolean resize;
@@ -130,14 +124,14 @@ class FontTexture implements PConstants {
       // 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));
+        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));
+        new Texture.Parameters(ARGB, Texture.LINEAR, false));
     }
 
     if (textures == null) {
@@ -177,23 +171,19 @@ class FontTexture implements PConstants {
     return resize;
   }
 
-
   public void begin() {
   }
 
-
   public void end() {
-    for (int i = 0; i < textures.length; i++) {
-      pgl.disableTexturing(textures[i].glTarget);
+    for (Texture texture : textures) {
+      pgl.disableTexturing(texture.glTarget);
     }
   }
 
-
   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.
@@ -202,24 +192,20 @@ class FontTexture implements PConstants {
     }
   }
 
-
   public void updateGlyphsTexCoords() {
     // loop over current glyphs.
-    for (int i = 0; i < glyphTexinfos.length; i++) {
-      TextureInfo tinfo = glyphTexinfos[i];
+    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) {
@@ -229,17 +215,16 @@ class FontTexture implements PConstants {
     return glyphTexinfos[n];
   }
 
-
   public boolean contextIsOutdated() {
     boolean outdated = false;
-    for (int i = 0; i < textures.length; i++) {
-      if (textures[i].contextIsOutdated())  {
+    for (Texture texture : textures) {
+      if (texture.contextIsOutdated()) {
         outdated = true;
       }
     }
     if (outdated) {
-      for (int i = 0; i < textures.length; i++) {
-        textures[i].dispose();
+      for (Texture texture : textures) {
+        texture.dispose();
       }
     }
     return outdated;
@@ -251,8 +236,6 @@ 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
@@ -271,7 +254,7 @@ class FontTexture implements PConstants {
     int[] rgba = new int[w * h];
     int t = 0;
     int p = 0;
-    if (PGL.BIG_ENDIAN)  {
+    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++) {
@@ -333,8 +316,8 @@ class FontTexture implements PConstants {
     texinfoMap.put(glyph, tinfo);
   }
 
-
   class TextureInfo {
+
     int texIndex;
     int width;
     int height;
@@ -344,7 +327,7 @@ class FontTexture implements PConstants {
     int[] pixels;
 
     TextureInfo(int tidx, int cropX, int cropY, int cropW, int cropH,
-                int[] pix) {
+      int[] pix) {
       texIndex = tidx;
       crop = new int[4];
       // The region of the texture corresponding to the glyph is surrounded by a
@@ -359,21 +342,19 @@ class FontTexture implements PConstants {
       updateTex();
     }
 
-
-    void updateUV() {
+    final 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;
+      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() {
+    final void updateTex() {
       textures[texIndex].setNative(pixels, crop[0] - 1, crop[1] + crop[3] - 1,
-                                           crop[2] + 2, -crop[3] + 2);
+        crop[2] + 2, -crop[3] + 2);
     }
   }
 }

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

@@ -393,9 +393,7 @@ public class FrameBuffer implements PConstants {
                                  "buffers.");
     }
 
-    for (int i = 0; i < numColorBuffers; i++) {
-      colorBufferTex[i] = textures[i];
-    }
+      System.arraycopy(textures, 0, colorBufferTex, 0, numColorBuffers);
 
     pg.pushFramebuffer();
     pg.setFramebuffer(this);
@@ -474,7 +472,7 @@ public class FrameBuffer implements PConstants {
      */
 
 
-  protected void allocate() {
+  protected final void allocate() {
     dispose(); // Just in the case this object is being re-allocated.
 
     context = pgl.getCurrentContext();
@@ -598,13 +596,19 @@ public class FrameBuffer implements PConstants {
     pgl.bindRenderbuffer(PGL.RENDERBUFFER, glDepth);
 
     int glConst = PGL.DEPTH_COMPONENT16;
-    if (depthBits == 16) {
-      glConst = PGL.DEPTH_COMPONENT16;
-    } else if (depthBits == 24) {
-      glConst = PGL.DEPTH_COMPONENT24;
-    } else if (depthBits == 32) {
-      glConst = PGL.DEPTH_COMPONENT32;
-    }
+      switch (depthBits) {
+        case 16:
+          glConst = PGL.DEPTH_COMPONENT16;
+          break;
+        case 24:
+          glConst = PGL.DEPTH_COMPONENT24;
+          break;
+        case 32:
+          glConst = PGL.DEPTH_COMPONENT32;
+          break;
+        default:
+          break;
+      }
 
     if (multisample) {
       pgl.renderbufferStorageMultisample(PGL.RENDERBUFFER, nsamples, glConst,
@@ -635,13 +639,19 @@ public class FrameBuffer implements PConstants {
     pgl.bindRenderbuffer(PGL.RENDERBUFFER, glStencil);
 
     int glConst = PGL.STENCIL_INDEX1;
-    if (stencilBits == 1) {
-      glConst = PGL.STENCIL_INDEX1;
-    } else if (stencilBits == 4) {
-      glConst = PGL.STENCIL_INDEX4;
-    } else if (stencilBits == 8) {
-      glConst = PGL.STENCIL_INDEX8;
-    }
+      switch (stencilBits) {
+        case 1:
+          glConst = PGL.STENCIL_INDEX1;
+          break;
+        case 4:
+          glConst = PGL.STENCIL_INDEX4;
+          break;
+        case 8:
+          glConst = PGL.STENCIL_INDEX8;
+          break;
+        default:
+          break;
+      }
     if (multisample) {
       pgl.renderbufferStorageMultisample(PGL.RENDERBUFFER, nsamples, glConst,
                                          width, height);

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

@@ -357,7 +357,7 @@ public class LinePath {
 
     LinePath path;
 
-    static final int curvecoords[] = { 2, 2, 0 };
+    static final int[] CURVE_COORDS = { 2, 2, 0 };
 
     PathIterator(LinePath p2df) {
       this.path = p2df;
@@ -373,14 +373,14 @@ public class LinePath {
        */
       public int currentSegment(float[] coords) {
       int type = path.pointTypes[typeIdx];
-      int numCoords = curvecoords[type];
+      int numCoords = CURVE_COORDS[type];
       if (numCoords > 0) {
         System.arraycopy(floatCoords, pointIdx, coords, 0, numCoords);
         int color = path.pointColors[colorIdx];
         coords[numCoords + 0] = (color >> 24) & 0xFF;
         coords[numCoords + 1] = (color >> 16) & 0xFF;
         coords[numCoords + 2] = (color >>  8) & 0xFF;
-        coords[numCoords + 3] = (color >>  0) & 0xFF;
+        coords[numCoords + 3] = (color) & 0xFF;
       }
       return type;
     }
@@ -392,7 +392,7 @@ public class LinePath {
        */
       public int currentSegment(double[] coords) {
       int type = path.pointTypes[typeIdx];
-      int numCoords = curvecoords[type];
+      int numCoords = CURVE_COORDS[type];
       if (numCoords > 0) {
         for (int i = 0; i < numCoords; i++) {
           coords[i] = floatCoords[pointIdx + i];
@@ -401,7 +401,7 @@ public class LinePath {
         coords[numCoords + 0] = (color >> 24) & 0xFF;
         coords[numCoords + 1] = (color >> 16) & 0xFF;
         coords[numCoords + 2] = (color >>  8) & 0xFF;
-        coords[numCoords + 3] = (color >>  0) & 0xFF;
+        coords[numCoords + 3] = (color) & 0xFF;
       }
       return type;
     }
@@ -427,8 +427,8 @@ public class LinePath {
        */
       public void next() {
       int type = path.pointTypes[typeIdx++];
-      if (0 < curvecoords[type]) {
-        pointIdx += curvecoords[type];
+      if (0 < CURVE_COORDS[type]) {
+        pointIdx += CURVE_COORDS[type];
         colorIdx++;
       }
     }

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

@@ -61,9 +61,9 @@ public class LineStroker  {
 
   private boolean[] penIncluded;
   private int[] join;
-  private int[] offset = new int[2];
+  private final int[] offset = new int[2];
   private int[] reverse = new int[100];
-  private int[] miter = new int[2];
+  private final int[] miter = new int[2];
   private long miterLimitSq;
   private int prev;
   private int rindex;
@@ -118,7 +118,7 @@ public class LineStroker  {
    * @param output
    *          an output <code>LineStroker</code>.
    */
-  public void setOutput(LineStroker output) {
+  private void setOutput(LineStroker output) {
     this.output = output;
   }
 
@@ -141,7 +141,7 @@ public class LineStroker  {
    *          required in order to produce consistently shaped end caps and
    *          joins.
    */
-  public void setParameters(int lineWidth, int capStyle, int joinStyle,
+  public final void setParameters(int lineWidth, int capStyle, int joinStyle,
                             int miterLimit, PMatrix2D transform) {
     this.m00 = LinePath.FloatToS15_16(transform.m00);
     this.m01 = LinePath.FloatToS15_16(transform.m01);
@@ -262,18 +262,14 @@ public class LineStroker  {
     if (side == 0) {
       centerSide = side(cx, cy, xa, ya, xb, yb);
     } else {
-      centerSide = (side == 1) ? true : false;
+      centerSide = (side == 1);
     }
     for (int i = 0; i < numPenSegments; i++) {
       px = cx + pen_dx[i];
       py = cy + pen_dy[i];
 
       boolean penSide = side(px, py, xa, ya, xb, yb);
-      if (penSide != centerSide) {
-        penIncluded[i] = true;
-      } else {
-        penIncluded[i] = false;
-      }
+      penIncluded[i] = penSide != centerSide;
     }
 
     int start = -1, end = -1;

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

@@ -131,12 +131,12 @@ public abstract class PGL {
    * shorts as primitive type we have 2^15 = 32768 as the maximum number of
    * vertices that can be referred to within a single VBO.
    */
-  protected static int MAX_VERTEX_INDEX  = 32767;
+  protected static final int MAX_VERTEX_INDEX  = 32767;
 
     /**
      *
      */
-    protected static int MAX_VERTEX_INDEX1 = MAX_VERTEX_INDEX + 1;
+    protected static final int MAX_VERTEX_INDEX1 = MAX_VERTEX_INDEX + 1;
 
   /** Count of tessellated fill, line or point vertices that will
    * trigger a flush in the immediate mode. It doesn't necessarily
@@ -643,7 +643,7 @@ public abstract class PGL {
   // Constants
 
   /** Size of different types in bytes */
-  protected static int SIZEOF_SHORT = Short.SIZE / 8;
+  protected static final int SIZEOF_SHORT = Short.SIZE / 8;
 
     /**
      *
@@ -827,15 +827,16 @@ public abstract class PGL {
      * @return
      */
     static public int smoothToSamples(int smooth) {
-    if (smooth == 0) {
-      // smooth(0) is noSmooth(), which is 1x sampling
-      return 1;
-    } else if (smooth == 1) {
-      // smooth(1) means "default smoothing", which is 2x for OpenGL
-      return 2;
-    } else {
-      // smooth(N) can be used for 4x, 8x, etc
-      return smooth;
+    switch (smooth) {
+      case 0:
+        // smooth(0) is noSmooth(), which is 1x sampling
+        return 1;
+      case 1:
+        // smooth(1) means "default smoothing", which is 2x for OpenGL
+        return 2;
+      default:
+        // smooth(N) can be used for 4x, 8x, etc
+        return smooth;
     }
   }
 
@@ -905,7 +906,7 @@ public abstract class PGL {
      *
      * @return
      */
-    protected boolean isFBOBacked() {;
+    protected boolean isFBOBacked() {
     return fboLayerEnabled;
   }
 
@@ -966,7 +967,7 @@ public abstract class PGL {
     protected boolean getDepthTest() {
     intBuffer.rewind();
     getBooleanv(DEPTH_TEST, intBuffer);
-    return intBuffer.get(0) == 0 ? false : true;
+    return intBuffer.get(0) != 0;
   }
 
     /**
@@ -976,7 +977,7 @@ public abstract class PGL {
     protected boolean getDepthWriteMask() {
     intBuffer.rewind();
     getBooleanv(DEPTH_WRITEMASK, intBuffer);
-    return intBuffer.get(0) == 0 ? false : true;
+    return intBuffer.get(0) != 0;
   }
 
     /**
@@ -1306,13 +1307,13 @@ public abstract class PGL {
             float ba = ((stopButtonColor >> 24) & 0xFF) / 255f;
             float br = ((stopButtonColor >> 16) & 0xFF) / 255f;
             float bg = ((stopButtonColor >>  8) & 0xFF) / 255f;
-            float bb = ((stopButtonColor >>  0) & 0xFF) / 255f;
+            float bb = ((stopButtonColor) & 0xFF) / 255f;
             for (int i = 0; i < color.length; i++) {
               int c = closeButtonPix[i];
               int a = (int)(ba * ((c >> 24) & 0xFF));
               int r = (int)(br * ((c >> 16) & 0xFF));
               int g = (int)(bg * ((c >>  8) & 0xFF));
-              int b = (int)(bb * ((c >>  0) & 0xFF));
+              int b = (int)(bb * ((c) & 0xFF));
               color[i] = javaToNativeARGB((a << 24) | (r << 16) | (g << 8) | b);
             }
             IntBuffer buf = allocateIntBuffer(color);
@@ -1614,12 +1615,18 @@ public abstract class PGL {
       // separate depth and stencil buffers
       if (0 < depthBits) {
         int depthComponent = DEPTH_COMPONENT16;
-        if (depthBits == 32) {
-          depthComponent = DEPTH_COMPONENT32;
-        } else if (depthBits == 24) {
-          depthComponent = DEPTH_COMPONENT24;
-        } else if (depthBits == 16) {
-          depthComponent = DEPTH_COMPONENT16;
+        switch (depthBits) {
+          case 32:
+            depthComponent = DEPTH_COMPONENT32;
+            break;
+          case 24:
+            depthComponent = DEPTH_COMPONENT24;
+            break;
+          case 16:
+            depthComponent = DEPTH_COMPONENT16;
+            break;
+          default:
+            break;
         }
 
         IntBuffer depthBuf = multisample ? glMultiDepth : glDepth;
@@ -1638,12 +1645,18 @@ public abstract class PGL {
 
       if (0 < stencilBits) {
         int stencilIndex = STENCIL_INDEX1;
-        if (stencilBits == 8) {
-          stencilIndex = STENCIL_INDEX8;
-        } else if (stencilBits == 4) {
-          stencilIndex = STENCIL_INDEX4;
-        } else if (stencilBits == 1) {
-          stencilIndex = STENCIL_INDEX1;
+        switch (stencilBits) {
+          case 8:
+            stencilIndex = STENCIL_INDEX8;
+            break;
+          case 4:
+            stencilIndex = STENCIL_INDEX4;
+            break;
+          case 1:
+            stencilIndex = STENCIL_INDEX1;
+            break;
+          default:
+            break;
         }
 
         IntBuffer stencilBuf = multisample ? glMultiStencil : glStencil;
@@ -2824,8 +2837,7 @@ public abstract class PGL {
      * @return
      */
     protected static boolean containsVersionDirective(String[] shSrc) {
-    for (int i = 0; i < shSrc.length; i++) {
-      String line = shSrc[i];
+    for (String line : shSrc) {
       int versionIndex = line.indexOf("#version");
       if (versionIndex >= 0) {
         int commentIndex = line.indexOf("//");
@@ -2888,7 +2900,7 @@ public abstract class PGL {
     protected boolean compiled(int shader) {
     intBuffer.rewind();
     getShaderiv(shader, COMPILE_STATUS, intBuffer);
-    return intBuffer.get(0) == 0 ? false : true;
+    return intBuffer.get(0) != 0;
   }
 
     /**
@@ -2899,7 +2911,7 @@ public abstract class PGL {
     protected boolean linked(int program) {
     intBuffer.rewind();
     getProgramiv(program, LINK_STATUS, intBuffer);
-    return intBuffer.get(0) == 0 ? false : true;
+    return intBuffer.get(0) != 0;
   }
 
     /**
@@ -2970,9 +2982,9 @@ public abstract class PGL {
 
     int[] res = {0, 0, 0};
     String[] parts = version.split(" ");
-    for (int i = 0; i < parts.length; i++) {
-      if (0 < parts[i].indexOf(".")) {
-        String nums[] = parts[i].split("\\.");
+    for (String part : parts) {
+      if (0 < part.indexOf(".")) {
+        String[] nums = part.split("\\.");
         try {
           res[0] = Integer.parseInt(nums[0]);
         } catch (NumberFormatException e) { }
@@ -3001,10 +3013,10 @@ public abstract class PGL {
     int major = getGLVersion()[0];
     if (major < 2) {
       String ext = getString(EXTENSIONS);
-      return ext.indexOf("_framebuffer_object") != -1 &&
-             ext.indexOf("_vertex_shader")      != -1 &&
-             ext.indexOf("_shader_objects")     != -1 &&
-             ext.indexOf("_shading_language")   != -1;
+      return ext.contains("_framebuffer_object") &&
+        ext.contains("_vertex_shader") &&
+        ext.contains("_shader_objects") &&
+        ext.contains("_shading_language");
     } else {
       return true;
     }
@@ -3021,10 +3033,10 @@ public abstract class PGL {
     int major = getGLVersion()[0];
     if (major < 2) {
       String ext = getString(EXTENSIONS);
-      return ext.indexOf("_fragment_shader")  != -1 &&
-             ext.indexOf("_vertex_shader")    != -1 &&
-             ext.indexOf("_shader_objects")   != -1 &&
-             ext.indexOf("_shading_language") != -1;
+      return ext.contains("_fragment_shader") &&
+        ext.contains("_vertex_shader") &&
+        ext.contains("_shader_objects") &&
+        ext.contains("_shading_language");
     } else {
       return true;
     }