propane 3.7.1-java → 3.11.0-java

data/src/main/java/processing/core/PGraphics.java

@@ -30,9 +30,11 @@ import java.awt.Color;
 
 // Used for the 'image' object that's been here forever
 import java.awt.Font;
+import java.awt.FontFormatException;
 import java.awt.Image;
 
 import java.io.File;
+import java.io.IOException;
 import java.io.InputStream;
 import java.util.Map;
 import java.util.HashMap;
@@ -626,8 +628,8 @@ public class PGraphics extends PImage implements PConstants {
     sinLUT = new float[SINCOS_LENGTH];
     cosLUT = new float[SINCOS_LENGTH];
     for (int i = 0; i < SINCOS_LENGTH; i++) {
-      sinLUT[i] = (float) Math.sin(i * DEG_TO_RAD * SINCOS_PRECISION);
-      cosLUT[i] = (float) Math.cos(i * DEG_TO_RAD * SINCOS_PRECISION);
+      sinLUT[i] = (float) Math.sin(Math.toRadians(i * SINCOS_PRECISION));
+      cosLUT[i] = (float) Math.cos(Math.toRadians(i * SINCOS_PRECISION));
     }
   }
 
@@ -1984,35 +1986,32 @@ public class PGraphics extends PImage implements PConstants {
    * @param d height of the rectangle, by default
    */
   public void clip(float a, float b, float c, float d) {
-    if (imageMode == CORNER) {
-      if (c < 0) {  // reset a negative width
-        a += c; c = -c;
+      switch (imageMode) {
+          case CORNER:
+              if (c < 0) {  // reset a negative width
+                  a += c; c = -c;
+              }       if (d < 0) {  // reset a negative height
+                  b += d; d = -d;
+              }       clipImpl(a, b, a + c, b + d);
+              break;
+          case CORNERS:
+              if (c < a) {  // reverse because x2 < x1
+                  float temp = a; a = c; c = temp;
+              }       if (d < b) {  // reverse because y2 < y1
+                  float temp = b; b = d; d = temp;
+              }       clipImpl(a, b, c, d);
+              break;
+          case CENTER:
+              // c and d are width/height
+              if (c < 0) c = -c;
+              if (d < 0) d = -d;
+              float x1 = a - c/2;
+              float y1 = b - d/2;
+              clipImpl(x1, y1, x1 + c, y1 + d);
+              break;
+          default:
+              break;
       }
-      if (d < 0) {  // reset a negative height
-        b += d; d = -d;
-      }
-
-      clipImpl(a, b, a + c, b + d);
-
-    } else if (imageMode == CORNERS) {
-      if (c < a) {  // reverse because x2 < x1
-        float temp = a; a = c; c = temp;
-      }
-      if (d < b) {  // reverse because y2 < y1
-        float temp = b; b = d; d = temp;
-      }
-
-      clipImpl(a, b, c, d);
-
-    } else if (imageMode == CENTER) {
-      // c and d are width/height
-      if (c < 0) c = -c;
-      if (d < 0) d = -d;
-      float x1 = a - c/2;
-      float y1 = b - d/2;
-
-      clipImpl(x1, y1, x1 + c, y1 + d);
-    }
   }
 
 
@@ -2811,20 +2810,24 @@ public class PGraphics extends PImage implements PConstants {
     float w = c;
     float h = d;
 
-    if (ellipseMode == CORNERS) {
-      w = c - a;
-      h = d - b;
-
-    } else if (ellipseMode == RADIUS) {
-      x = a - c;
-      y = b - d;
-      w = c * 2;
-      h = d * 2;
-
-    } else if (ellipseMode == DIAMETER) {
-      x = a - c/2f;
-      y = b - d/2f;
-    }
+      switch (ellipseMode) {
+          case CORNERS:
+              w = c - a;
+              h = d - b;
+              break;
+          case RADIUS:
+              x = a - c;
+              y = b - d;
+              w = c * 2;
+              h = d * 2;
+              break;
+          case DIAMETER:
+              x = a - c/2f;
+              y = b - d/2f;
+              break;
+          default:
+              break;
+      }
 
     if (w < 0) {  // undo negative width
       x += w;
@@ -2881,20 +2884,24 @@ public class PGraphics extends PImage implements PConstants {
     float w = c;
     float h = d;
 
-    if (ellipseMode == CORNERS) {
-      w = c - a;
-      h = d - b;
-
-    } else if (ellipseMode == RADIUS) {
-      x = a - c;
-      y = b - d;
-      w = c * 2;
-      h = d * 2;
-
-    } else if (ellipseMode == CENTER) {
-      x = a - c/2f;
-      y = b - d/2f;
-    }
+      switch (ellipseMode) {
+          case CORNERS:
+              w = c - a;
+              h = d - b;
+              break;
+          case RADIUS:
+              x = a - c;
+              y = b - d;
+              w = c * 2;
+              h = d * 2;
+              break;
+          case CENTER:
+              x = a - c/2f;
+              y = b - d/2f;
+              break;
+          default:
+              break;
+      }
 
     // make sure the loop will exit before starting while
     if (!Float.isInfinite(start) && !Float.isInfinite(stop)) {
@@ -3854,41 +3861,38 @@ public class PGraphics extends PImage implements PConstants {
     // loadImageAsync() sets width and height to -1 when loading fails.
     if (img.width == -1 || img.height == -1) return;
 
-    if (imageMode == CORNER) {
-      if (c < 0) {  // reset a negative width
-        a += c; c = -c;
-      }
-      if (d < 0) {  // reset a negative height
-        b += d; d = -d;
+      switch (imageMode) {
+          case CORNER:
+              if (c < 0) {  // reset a negative width
+                  a += c; c = -c;
+              }       if (d < 0) {  // reset a negative height
+                  b += d; d = -d;
+              }       imageImpl(img,
+                      a, b, a + c, b + d,
+                      u1, v1, u2, v2);
+              break;
+          case CORNERS:
+              if (c < a) {  // reverse because x2 < x1
+                  float temp = a; a = c; c = temp;
+              }       if (d < b) {  // reverse because y2 < y1
+                  float temp = b; b = d; d = temp;
+              }       imageImpl(img,
+                      a, b, c, d,
+                      u1, v1, u2, v2);
+              break;
+          case CENTER:
+              // c and d are width/height
+              if (c < 0) c = -c;
+              if (d < 0) d = -d;
+              float x1 = a - c/2;
+              float y1 = b - d/2;
+              imageImpl(img,
+                      x1, y1, x1 + c, y1 + d,
+                      u1, v1, u2, v2);
+              break;
+          default:
+              break;
       }
-
-      imageImpl(img,
-                a, b, a + c, b + d,
-                u1, v1, u2, v2);
-
-    } else if (imageMode == CORNERS) {
-      if (c < a) {  // reverse because x2 < x1
-        float temp = a; a = c; c = temp;
-      }
-      if (d < b) {  // reverse because y2 < y1
-        float temp = b; b = d; d = temp;
-      }
-
-      imageImpl(img,
-                a, b, c, d,
-                u1, v1, u2, v2);
-
-    } else if (imageMode == CENTER) {
-      // c and d are width/height
-      if (c < 0) c = -c;
-      if (d < 0) d = -d;
-      float x1 = a - c/2;
-      float y1 = b - d/2;
-
-      imageImpl(img,
-                x1, y1, x1 + c, y1 + d,
-                u1, v1, u2, v2);
-    }
   }
 
 
@@ -4062,6 +4066,7 @@ public class PGraphics extends PImage implements PConstants {
 
 
   /**
+     * @param shape
    * @param a x-coordinate of the shape
    * @param b y-coordinate of the shape
    * @param c width to display the shape
@@ -4073,23 +4078,26 @@ public class PGraphics extends PImage implements PConstants {
 
       pushMatrix();
 
-      if (shapeMode == CENTER) {
-        // x and y are center, c and d refer to a diameter
-        translate(a - c/2f, b - d/2f);
-        scale(c / shape.getWidth(), d / shape.getHeight());
-
-      } else if (shapeMode == CORNER) {
-        translate(a, b);
-        scale(c / shape.getWidth(), d / shape.getHeight());
-
-      } else if (shapeMode == CORNERS) {
-        // c and d are x2/y2, make them into width/height
-        c -= a;
-        d -= b;
-        // then same as above
-        translate(a, b);
-        scale(c / shape.getWidth(), d / shape.getHeight());
-      }
+        switch (shapeMode) {
+            case CENTER:
+                // x and y are center, c and d refer to a diameter
+                translate(a - c/2f, b - d/2f);
+                scale(c / shape.getWidth(), d / shape.getHeight());
+                break;
+            case CORNER:
+                translate(a, b);
+                scale(c / shape.getWidth(), d / shape.getHeight());
+                break;
+            case CORNERS:
+                // c and d are x2/y2, make them into width/height
+                c -= a; d -= b;
+                // then same as above
+                translate(a, b);
+                scale(c / shape.getWidth(), d / shape.getHeight());
+                break;
+            default:
+                break;
+        }
       shape.draw(this);
 
       popMatrix();
@@ -4141,9 +4149,8 @@ public class PGraphics extends PImage implements PConstants {
       }
       return createFont(baseFont, size, smooth, charset, stream != null);
 
-    } catch (Exception e) {
+    } catch (FontFormatException | IOException e) {
       System.err.println("Problem with createFont(\"" + name + "\")");
-      e.printStackTrace();
       return null;
     }
   }

data/src/main/java/processing/core/PImage.java

@@ -1567,24 +1567,24 @@ public class PImage implements PConstants, Cloneable {
    *     Sometimes called "Normal" or "Copy" in other software.
    *
    * <LI>BLEND - linear interpolation of colours:
-   *     <TT>C = A*factor + B</TT>
+   *     <code>C = A*factor + B</code>
    *
    * <LI>ADD - additive blending with white clip:
-   *     <TT>C = min(A*factor + B, 255)</TT>.
+   *     <code>C = min(A*factor + B, 255)</code>.
    *     Clipped to 0..255, Photoshop calls this "Linear Burn",
    *     and Director calls it "Add Pin".
    *
    * <LI>SUBTRACT - substractive blend with black clip:
-   *     <TT>C = max(B - A*factor, 0)</TT>.
+   *     <code>C = max(B - A*factor, 0)</code>.
    *     Clipped to 0..255, Photoshop calls this "Linear Dodge",
    *     and Director calls it "Subtract Pin".
    *
    * <LI>DARKEST - only the darkest colour succeeds:
-   *     <TT>C = min(A*factor, B)</TT>.
+   *     <code>C = min(A*factor, B)</code>.
    *     Illustrator calls this "Darken".
    *
    * <LI>LIGHTEST - only the lightest colour succeeds:
-   *     <TT>C = max(A*factor, B)</TT>.
+   *     <code>C = max(A*factor, B)</code>.
    *     Illustrator calls this "Lighten".
    *
    * <LI>DIFFERENCE - subtract colors from underlying image.
@@ -1615,12 +1615,12 @@ public class PImage implements PConstants, Cloneable {
    * <P>It is important to note that Processing uses "fast" code, not
    * necessarily "correct" code. No biggie, most software does. A nitpicker
    * can find numerous "off by 1 division" problems in the blend code where
-   * <TT>&gt;&gt;8</TT> or <TT>&gt;&gt;7</TT> is used when strictly speaking
-   * <TT>/255.0</TT> or <TT>/127.0</TT> should have been used.</P>
+   * <code>&gt;&gt;8</code> or <code>&gt;&gt;7</code> is used when strictly speaking
+   * <code>/255.0</code> or <code>/127.0</code> should have been used.</P>
    * <P>For instance, exclusion (not intended for real-time use) reads
-   * <TT>r1 + r2 - ((2 * r1 * r2) / 255)</TT> because <TT>255 == 1.0</TT>
-   * not <TT>256 == 1.0</TT>. In other words, <TT>(255*255)>>8</TT> is not
-   * the same as <TT>(255*255)/255</TT>. But for real-time use the shifts
+   * <code>r1 + r2 - ((2 * r1 * r2) / 255)</code> because <code>255 == 1.0</code>
+   * not <code>256 == 1.0</code>. In other words, <code>(255*255)>>8</code> is not
+   * the same as <code>(255*255)/255</code>. But for real-time use the shifts
    * are preferrable, and the difference is insignificant for applications
    * built with Processing.</P>
    *
@@ -3130,9 +3130,9 @@ int testFunction(int dst, int src) {
    * </p>
    * Starting with revision 0092, the format setting is taken into account:
    * <UL>
-   * <LI><TT>ALPHA</TT> images written as 8bit grayscale (uses lowest byte)
-   * <LI><TT>RGB</TT> &rarr; 24 bits
-   * <LI><TT>ARGB</TT> &rarr; 32 bits
+   * <LI><code>ALPHA</code> images written as 8bit grayscale (uses lowest byte)
+   * <LI><code>RGB</code> &rarr; 24 bits
+   * <LI><code>ARGB</code> &rarr; 32 bits
    * </UL>
    * All versions are RLE compressed.
    * 
@@ -3307,7 +3307,7 @@ int testFunction(int dst, int src) {
    * and the extension used is supported (usually png, jpg, jpeg, bmp,
    * and tiff), then those methods will be used to write the image.
    * To get a list of the supported formats for writing, use: <BR>
-   * <TT>println(javax.imageio.ImageIO.getReaderFormatNames())</TT>
+   * <code>println(javax.imageio.ImageIO.getReaderFormatNames())</code>
    * <p>
    * To use the original built-in image writers, use .tga or .tif as the
    * extension, or don't include an extension. When no extension is used,

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

@@ -181,32 +181,32 @@ public class PGraphicsOpenGL extends PGraphics {
   // Shaders
 
   static protected URL defColorShaderVertURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/ColorVert.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/ColorVert.glsl");
   static protected URL defTextureShaderVertURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexVert.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/TexVert.glsl");
   static protected URL defLightShaderVertURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/LightVert.glsl");
   static protected URL defTexlightShaderVertURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightVert.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/TexLightVert.glsl");
   static protected URL defColorShaderFragURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/ColorFrag.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/ColorFrag.glsl");
   static protected URL defTextureShaderFragURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexFrag.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/TexFrag.glsl");
   static protected URL defLightShaderFragURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightFrag.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/LightFrag.glsl");
   static protected URL defTexlightShaderFragURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightFrag.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/TexLightFrag.glsl");
 
   static protected URL defLineShaderVertURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LineVert.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/LineVert.glsl");
   static protected URL defLineShaderFragURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LineFrag.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/LineFrag.glsl");
   static protected URL defPointShaderVertURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/PointVert.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/PointVert.glsl");
   static protected URL defPointShaderFragURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/PointFrag.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/PointFrag.glsl");
   static protected URL maskShaderFragURL =
-    PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/MaskFrag.glsl");
+    PGraphicsOpenGL.class.getResource("/shaders/MaskFrag.glsl");
 
   protected PShader defColorShader;
   protected PShader defTextureShader;

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

@@ -182,7 +182,7 @@ public class PJOGL extends PGL {
   @Override
   protected PImage screenshot() {
     AWTGLReadBufferUtil util = new AWTGLReadBufferUtil(capabilities.getGLProfile(), false);
-    return new PImageAWT(util.readPixelsToBufferedImage​(gl, true));
+    return new PImageAWT(util.readPixelsToBufferedImage(gl, true));
   }
 
 
@@ -637,6 +637,7 @@ public class PJOGL extends PGL {
       setProperty(GLU.GLU_TESS_WINDING_RULE, rule);
     }
 
+    @Override
     public void setProperty(int property, int value) {
       GLU.gluTessProperty(tess, property, value);
     }
@@ -1997,10 +1998,10 @@ public class PJOGL extends PGL {
     } else if (gl3 != null) {
       gl3.glDrawBuffer(buf);
     } else if (gl3es3 != null) {
-      IntBuffer intBuffer = IntBuffer.allocate(1);
-      intBuffer.put(buf);
-      intBuffer.rewind();
-      gl3es3.glDrawBuffers(1, intBuffer);
+      IntBuffer localIntBuf = IntBuffer.allocate(1);
+      localIntBuf.put(buf);
+      localIntBuf.rewind();
+      gl3es3.glDrawBuffers(1, localIntBuf);
     } else {
       throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glDrawBuffer()"));
     }

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

@@ -988,7 +988,7 @@ public class PShader implements PConstants {
 
 
   /**
-   * @return 
+   * @return
    */
   protected boolean compileFragmentShader() {
     pgl.shaderSource(glFragment, PApplet.join(fragmentShaderSource, "\n"));
@@ -1137,11 +1137,6 @@ public class PShader implements PConstants {
     specularLoc = getAttributeLoc("specular");
     emissiveLoc = getAttributeLoc("emissive");
     shininessLoc = getAttributeLoc("shininess");
-
-    directionLoc = getAttributeLoc("direction");
-
-    offsetLoc = getAttributeLoc("offset");
-
     directionLoc = getAttributeLoc("direction");
     offsetLoc = getAttributeLoc("offset");
 

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

@@ -184,10 +184,10 @@ public class PSurfaceJOGL implements PSurface {
       boolean hide = (sketch != null) &&
         (PApplet.platform == PConstants.WINDOWS);
       if (hide) setVisible(false);
-      
+
       ShimAWT.selectFolderImpl(prompt, callbackMethod, file,
         callbackObject, null);
-      
+
       if (hide) setVisible(true);
     });
   }
@@ -273,7 +273,7 @@ public class PSurfaceJOGL implements PSurface {
         case 2:
           try {
             profile = GLProfile.getGL2ES2();
-            
+
             // workaround for https://jogamp.org/bugzilla/show_bug.cgi?id=1347
             if (!profile.isHardwareRasterizer()) {
               GLProfile hardware = GLProfile.getMaxProgrammable(true);
@@ -281,7 +281,7 @@ public class PSurfaceJOGL implements PSurface {
                 profile = hardware;
               }
             }
-            
+
           } catch (GLException ex) {
             profile = GLProfile.getMaxProgrammable(true);
           } break;
@@ -657,7 +657,7 @@ public class PSurfaceJOGL implements PSurface {
           stream = new FileInputStream(filename);
           stream.close();
           return filename;
-        
+
         } catch (IOException e1) { }
 
       } catch (SecurityException se) { }  // online, whups
@@ -1309,7 +1309,7 @@ public class PSurfaceJOGL implements PSurface {
       String name = cursorNames.get(kind);
       if (name != null) {
         ImageIcon icon =
-          new ImageIcon(getClass().getResource("cursors/" + name + ".png"));
+          new ImageIcon(getClass().getResource("/cursors/" + name + ".png"));
         PImage img = new PImageAWT(icon.getImage());
         // Most cursors just use the center as the hotspot...
         int x = img.width / 2;