propane 3.5.0-java → 3.9.0-java

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

@@ -258,9 +258,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);
@@ -327,7 +325,7 @@ public class FrameBuffer implements PConstants {
   // Allocate/release framebuffer.
 
 
-  protected void allocate() {
+  protected final void allocate() {
     dispose(); // Just in the case this object is being re-allocated.
 
     context = pgl.getCurrentContext();

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

@@ -219,6 +219,7 @@ public class LinePath {
    *          the specified X coordinate
    * @param y
    *          the specified Y coordinate
+   * @param c
    * @see LinePath#moveTo
    */
   public final void moveTo(float x, float y, int c) {
@@ -247,6 +248,7 @@ public class LinePath {
    *          the specified X coordinate
    * @param y
    *          the specified Y coordinate
+   * @param c
    * @see LinePath#lineTo
    */
   public final void lineTo(float x, float y, int c) {
@@ -263,6 +265,7 @@ public class LinePath {
    * the {@code LinePath} class does not guarantee that modifications to the
    * geometry of this {@code LinePath} object do not affect any iterations of that
    * geometry that are already in process.
+   * @return 
    */
   public PathIterator getPathIterator() {
     return new PathIterator(this);
@@ -421,6 +424,7 @@ public class LinePath {
    *          the decoration applied where path segments meet
    * @param miterlimit
    * @param transform
+   * @return 
    *
    */
   static public LinePath createStrokedPath(LinePath src, float weight,

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

@@ -258,18 +258,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

@@ -33,12 +33,12 @@ import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 import java.nio.ShortBuffer;
 import java.util.Arrays;
-import java.util.Optional;
 import java.util.regex.Pattern;
 
 import processing.core.PApplet;
 import processing.core.PConstants;
 import processing.core.PGraphics;
+import processing.core.PImage;
 
 
 /**
@@ -56,6 +56,7 @@ public abstract class PGL {
   /** The PGraphics and PApplet objects using this interface */
   protected PGraphicsOpenGL graphics;
   protected PApplet sketch;
+  protected RenderCallback renderCallback;
 
   /** OpenGL thread */
   protected Thread glThread;
@@ -96,8 +97,8 @@ 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 int MAX_VERTEX_INDEX1 = MAX_VERTEX_INDEX + 1;
+  protected static final int MAX_VERTEX_INDEX  = 32767;
+  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
@@ -170,9 +171,12 @@ public abstract class PGL {
    * Defines if FBO Layer is allowed in the given environment.
    * Using FBO can cause a fatal error during runtime for
    * Intel HD Graphics 3000 chipsets (commonly used on older MacBooks)
-   * <a href="https://github.com/processing/processing/issues/4104">#4104</a>
+   * <a href="https://github.com/processing/processing/issues/4104">#4104</a>.
+   * Changed to private because needs to be accessed via isFboAllowed().
+   * <a href="https://github.com/processing/processing4/pull/76">#76</a> and
+   * <a href="https://github.com/processing/processing4/issues/50">#50</a>
    */
-  private Optional<Boolean> fboAllowed = Optional.empty();
+  private Boolean fboAllowed = true;
 
   // ........................................................
 
@@ -330,7 +334,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;
   protected static int SIZEOF_INT   = Integer.SIZE / 8;
   protected static int SIZEOF_FLOAT = Float.SIZE / 8;
   protected static int SIZEOF_BYTE  = Byte.SIZE / 8;
@@ -398,11 +402,26 @@ public abstract class PGL {
   // Initialization, finalization
 
 
-  public PGL() { }
+  public PGL() {
+    this.renderCallback = () -> {};
+  }
 
 
   public PGL(PGraphicsOpenGL pg) {
     this.graphics = pg;
+    this.renderCallback = () -> {};
+    initGraphics();
+  }
+
+
+  public PGL(PGraphicsOpenGL pg, RenderCallback newCallback) {
+    this.graphics = pg;
+    this.renderCallback = newCallback;
+    initGraphics();
+  }
+
+
+  private void initGraphics() {
     if (glColorTex == null) {
       glColorFbo = allocateIntBuffer(1);
       glColorTex = allocateIntBuffer(2);
@@ -463,6 +482,9 @@ public abstract class PGL {
   abstract protected void registerListeners();
 
 
+  abstract protected PImage screenshot();
+
+
   protected int getReadFramebuffer()  {
     return fboLayerEnabled ? glColorFbo.get(0) : 0;
   }
@@ -525,14 +547,14 @@ public abstract class PGL {
   protected boolean getDepthTest() {
     intBuffer.rewind();
     getBooleanv(DEPTH_TEST, intBuffer);
-    return intBuffer.get(0) != 0;
+    return intBuffer.get(0) == 0 ? false : true;
   }
 
 
   protected boolean getDepthWriteMask() {
     intBuffer.rewind();
     getBooleanv(DEPTH_WRITEMASK, intBuffer);
-    return intBuffer.get(0) != 0;
+    return intBuffer.get(0) == 0 ? false : true;
   }
 
 
@@ -809,13 +831,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);
@@ -862,7 +884,7 @@ public abstract class PGL {
         saveFirstFrame();
       }
 
-      if (getIsFboAllowed()) {
+      if (isFboAllowed()) {
         if (!clearColor && 0 < sketch.frameCount || !sketch.isLooping()) {
           enableFBOLayer();
           if (SINGLE_BUFFERED) {
@@ -871,6 +893,8 @@ public abstract class PGL {
         }
       }
     }
+
+    renderCallback.onRender();
   }
 
 
@@ -1117,12 +1141,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;
@@ -1615,6 +1645,8 @@ public abstract class PGL {
   /**
    * Converts input native OpenGL value (RGBA on big endian, ABGR on little
    * endian) to Java ARGB.
+   * @param color
+   * @return 
    */
   protected static int nativeToJavaARGB(int color) {
     if (BIG_ENDIAN) { // RGBA to ARGB
@@ -1791,10 +1823,11 @@ public abstract class PGL {
     }
   }
 
-
   /**
    * Converts input Java ARGB value to native OpenGL format (RGBA on big endian,
    * BGRA on little endian), setting alpha component to opaque (255).
+   * @param color
+   * @return 
    */
   protected static int javaToNativeRGB(int color) {
     if (BIG_ENDIAN) { // ARGB to RGB
@@ -2307,39 +2340,26 @@ public abstract class PGL {
     return intBuffer.get(0);
   }
 
-
-  /**
-   * Determine if the renderer / hardware supports frame buffer objects (FBOs).
-   *
-   * @return True if confirmed that FBOs are supported by the renderer on the current hardware. Will
-   *    be false if the support status has not been confirmed yet (for example, because the graphics
-   *    context has not been itiliazed) or if it is confirmed that the renderer / hardware
-   *    combination do not support FBOs.
-   */
-  protected boolean getIsFboAllowed() {
-
-    // If not yet determined, try to find.
-    if (fboAllowed.isEmpty()) {
-      boolean isNoFboRenderer;
+  
+  public boolean isFboAllowed() {
+    if (fboAllowed == null) {
       if (PApplet.platform == PConstants.MACOS) {
-        String rendererName;
         try {
-          rendererName = getString(PGL.RENDERER);
-          isNoFboRenderer = String.valueOf(rendererName).contains("Intel HD Graphics 3000");
+          String hardware = getString(PGL.RENDERER);
+          if (hardware != null && hardware.contains("Intel HD Graphics 3000")) {
+            fboAllowed = false;
+            return false;
+          }
         } catch (RuntimeException e) {
           System.err.println("Could not read renderer name. FBOs disabled. Reason: " + e);
-          return false; // Try again later.
+          // disable for now, but will try again on next isFboAllowed() call
+          return false;
         }
-      } else {
-        isNoFboRenderer = false;
       }
-
-      // Cache value.
-      fboAllowed = Optional.of(!isNoFboRenderer);
+      // all other scenarios allow for FBOs
+      fboAllowed = true;
     }
-
-    // Return cached value.
-    return fboAllowed.get();
+    return fboAllowed;
   }
 
 
@@ -2723,6 +2743,13 @@ public abstract class PGL {
 
   abstract protected Object getDerivedFont(Object font, float size);
 
+  ///////////////////////////////////////////////////////////
+
+  protected interface RenderCallback {
+
+    void onRender();
+
+  }
 
   ///////////////////////////////////////////////////////////
 

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

@@ -47,13 +47,17 @@ public class PGraphicsOpenGL extends PGraphics {
   /** Font cache for texture objects. */
   protected WeakHashMap<PFont, FontTexture> fontMap;
 
+  // Blocking save
+  protected volatile Object saveBlocker;
+  private volatile Optional<String> saveTargetMaybe;
+
   // ........................................................
 
   // Disposal of native resources
   // Using the technique alternative to finalization described in:
   // http://www.oracle.com/technetwork/articles/java/finalization-137655.html
-  private static ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
-  private static List<Disposable<?>> reachableWeakReferences =
+  private static final ReferenceQueue<Object> refQueue = new ReferenceQueue<>();
+  private static final List<Disposable<?>> reachableWeakReferences =
     new LinkedList<>();
 
   static final private int MAX_DRAIN_GLRES_ITERATIONS = 10;
@@ -568,6 +572,9 @@ public class PGraphicsOpenGL extends PGraphics {
   public PGraphicsOpenGL() {
     pgl = createPGL(this);
 
+    saveTargetMaybe = Optional.empty();
+    saveBlocker = new Object();
+
     if (intBuffer == null) {
       intBuffer = PGL.allocateIntBuffer(2);
       floatBuffer = PGL.allocateFloatBuffer(2);
@@ -709,7 +716,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
   // Factory method
   protected PGL createPGL(PGraphicsOpenGL pg) {
-    return new PJOGL(pg);
+    return new PJOGL(pg, () -> { onRender(); });
 //    return new PGLES(pg);
   }
 
@@ -756,18 +763,30 @@ public class PGraphicsOpenGL extends PGraphics {
 //    return super.save(filename); // ASYNC save frame using PBOs not yet available on Android
 
     if (getHint(DISABLE_ASYNC_SAVEFRAME)) {
-      // Act as an opaque surface for the purposes of saving.
-      if (primaryGraphics) {
-        int prevFormat = format;
-        format = RGB;
-        boolean result = super.save(filename);
-        format = prevFormat;
-        return result;
+      saveTargetMaybe = Optional.of(filename);
+
+      if (!drawing) {
+        beginDraw();
       }
+      flush();
+      updatePixelSize();
+      endDraw(); // Briefly stop drawing
 
-      return super.save(filename);
+      synchronized(saveBlocker) {
+        try {
+          while (saveTargetMaybe.isPresent()) {
+            saveBlocker.wait();
+          }
+          beginDraw(); // Resume drawing
+          return true;
+        } catch (InterruptedException e) {
+          return false;
+        }
+      }
     }
 
+    boolean needEndDraw = false;
+
     if (asyncImageSaver == null) {
       asyncImageSaver = new AsyncImageSaver();
     }
@@ -781,7 +800,6 @@ public class PGraphicsOpenGL extends PGraphics {
     }
 
     if (asyncPixelReader != null && !loaded) {
-      boolean needEndDraw = false;
       if (!drawing) {
         beginDraw();
         needEndDraw = true;
@@ -810,6 +828,21 @@ public class PGraphicsOpenGL extends PGraphics {
   }
 
 
+  private void onRender() {
+    if (saveTargetMaybe.isEmpty()) {
+      return; // Nothing to save
+    }
+
+    PImage outputImage = pgl.screenshot();
+    outputImage.save(saveTargetMaybe.get());
+    saveTargetMaybe = Optional.empty();
+
+    synchronized(saveBlocker) {
+      saveBlocker.notify();
+    }
+  }
+
+
   //////////////////////////////////////////////////////////////
 
   // IMAGE METADATA FOR THIS RENDERER
@@ -920,7 +953,7 @@ public class PGraphicsOpenGL extends PGraphics {
     int glId;
 
     private PGL pgl;
-    private int context;
+    private final int context;
 
     public GLResourceVertexBuffer(VertexBuffer vbo) {
       super(vbo);
@@ -971,7 +1004,7 @@ public class PGraphicsOpenGL extends PGraphics {
     int glFragment;
 
     private PGL pgl;
-    private int context;
+    private final int context;
 
     public GLResourceShader(PShader sh) {
       super(sh);
@@ -1039,7 +1072,7 @@ public class PGraphicsOpenGL extends PGraphics {
     int glMultisample;
 
     private PGL pgl;
-    private int context;
+    private final int context;
 
     public GLResourceFrameBuffer(FrameBuffer fb) {
       super(fb);
@@ -4558,11 +4591,11 @@ public class PGraphicsOpenGL extends PGraphics {
    * Calls perspective() with Processing's standard coordinate projection.
    * <P>
    * Projection functions:
-   * <ul>
-   * <li>frustrum()
-   * <li>ortho()
-   * <li>perspective()
-   * </ul>
+   * <UL>
+   * <LI>frustrum()
+   * <LI>ortho()
+   * <LI>perspective()
+   * </UL>
    * Each of these three functions completely replaces the projection matrix
    * with a new one. They can be called inside setup(), and their effects will
    * be felt inside draw(). At the top of draw(), the projection matrix is not
@@ -4598,6 +4631,8 @@ public class PGraphicsOpenGL extends PGraphics {
    * against) the current perspective matrix.
    * <P>
    * Implementation based on the explanation in the OpenGL blue book.
+   * @param znear
+   * @param zfar
    */
   @Override
   public void frustum(float left, float right, float bottom, float top,
@@ -6938,15 +6973,16 @@ public class PGraphicsOpenGL extends PGraphics {
     maxTextureSize = intBuffer.get(0);
 
     // work around runtime exceptions in Broadcom's VC IV driver
-    if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {
-      pgl.getIntegerv(PGL.MAX_SAMPLES, intBuffer);
-      maxSamples = intBuffer.get(0);
-    }
+   // if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {
+    pgl.getIntegerv(PGL.MAX_SAMPLES, intBuffer);
+    maxSamples = intBuffer.get(0);
+   // }
 
     if (anisoSamplingSupported) {
       pgl.getFloatv(PGL.MAX_TEXTURE_MAX_ANISOTROPY, floatBuffer);
       maxAnisoAmount = floatBuffer.get(0);
     }
+
     glParamsRead = true;
   }
 
@@ -7073,15 +7109,21 @@ public class PGraphicsOpenGL extends PGraphics {
   @Override
   public void resetShader(int kind) {
     flush(); // Flushing geometry drawn with a different shader.
-
-    if (kind == TRIANGLES || kind == QUADS || kind == POLYGON) {
-      polyShader = null;
-    } else if (kind == LINES) {
-      lineShader = null;
-    } else if (kind == POINTS) {
-      pointShader = null;
-    } else {
-      PGraphics.showWarning(UNKNOWN_SHADER_KIND_ERROR);
+    switch (kind) {
+      case TRIANGLES:
+      case QUADS:
+      case POLYGON:
+        polyShader = null;
+        break;
+      case LINES:
+        lineShader = null;
+        break;
+      case POINTS:
+        pointShader = null;
+        break;
+      default:
+        PGraphics.showWarning(UNKNOWN_SHADER_KIND_ERROR);
+        break;
     }
   }
 
@@ -7450,7 +7492,7 @@ public class PGraphicsOpenGL extends PGraphics {
       allocate();
     }
 
-    void allocate() {
+    final void allocate() {
       textures = new PImage[PGL.DEFAULT_IN_TEXTURES];
       firstIndex = new int[PGL.DEFAULT_IN_TEXTURES];
       lastIndex = new int[PGL.DEFAULT_IN_TEXTURES];
@@ -7567,7 +7609,7 @@ public class PGraphicsOpenGL extends PGraphics {
       allocate();
     }
 
-    void allocate() {
+    final void allocate() {
       size = 0;
       indexCount = new int[2];
       indexOffset = new int[2];
@@ -7734,7 +7776,7 @@ public class PGraphicsOpenGL extends PGraphics {
       edgeCount = 0;
     }
 
-    void allocate() {
+    final void allocate() {
       vertices = new float[3 * PGL.DEFAULT_IN_VERTICES];
       colors = new int[PGL.DEFAULT_IN_VERTICES];
       normals = new float[3 * PGL.DEFAULT_IN_VERTICES];
@@ -8384,7 +8426,7 @@ public class PGraphicsOpenGL extends PGraphics {
 
         vert[R] = ((colors[i] >> 16) & 0xFF) / 255.0f;
         vert[G] = ((colors[i] >>  8) & 0xFF) / 255.0f;
-        vert[B] = ((colors[i] >>  0) & 0xFF) / 255.0f;
+        vert[B] = ((colors[i]) & 0xFF) / 255.0f;
         vert[A] = ((colors[i] >> 24) & 0xFF) / 255.0f;
 
         vert[U] = texcoords[2 * i + 0];
@@ -10661,31 +10703,32 @@ public class PGraphicsOpenGL extends PGraphics {
         polyEmissive[tessIdx] = in.emissive[inIdx];
         polyShininess[tessIdx] = in.shininess[inIdx];
 
-        for (String name: polyAttribs.keySet()) {
+        polyAttribs.keySet().forEach((name) -> {
           VertexAttribute attrib = polyAttribs.get(name);
-          if (attrib.isPosition() || attrib.isNormal()) continue;
-          int index0 = attrib.size * inIdx;
-          int index1 = attrib.size * tessIdx;
-          if (attrib.isFloat()) {
-            float[] inValues = in.fattribs.get(name);
-            float[] tessValues = fpolyAttribs.get(name);
-            for (int n = 0; n < attrib.size; n++) {
-              tessValues[index1++] = inValues[index0++];
-            }
-          } else if (attrib.isInt()) {
-            int[] inValues = in.iattribs.get(name);
-            int[] tessValues = ipolyAttribs.get(name);
-            for (int n = 0; n < attrib.size; n++) {
-              tessValues[index1++] = inValues[index0++];
-            }
-          } else if (attrib.isBool()) {
-            byte[] inValues = in.battribs.get(name);
-            byte[] tessValues = bpolyAttribs.get(name);
-            for (int n = 0; n < attrib.size; n++) {
-              tessValues[index1++] = inValues[index0++];
+          if (!(attrib.isPosition() || attrib.isNormal())) {
+            int index0 = attrib.size * inIdx;
+            int index1 = attrib.size * tessIdx;
+            if (attrib.isFloat()) {
+              float[] inValues = in.fattribs.get(name);
+              float[] tessValues = fpolyAttribs.get(name);
+              for (int n = 0; n < attrib.size; n++) {
+                tessValues[index1++] = inValues[index0++];
+              }
+            } else if (attrib.isInt()) {
+              int[] inValues = in.iattribs.get(name);
+              int[] tessValues = ipolyAttribs.get(name);
+              for (int n = 0; n < attrib.size; n++) {
+                tessValues[index1++] = inValues[index0++];
+              }
+            } else if (attrib.isBool()) {
+              byte[] inValues = in.battribs.get(name);
+              byte[] tessValues = bpolyAttribs.get(name);
+              for (int n = 0; n < attrib.size; n++) {
+                tessValues[index1++] = inValues[index0++];
+              }
             }
           }
-        }
+        });
       }
     }
 
@@ -12910,7 +12953,7 @@ public class PGraphicsOpenGL extends PGraphics {
       r[j++] = (fcol >> 24) & 0xFF; // fa
       r[j++] = (fcol >> 16) & 0xFF; // fr
       r[j++] = (fcol >>  8) & 0xFF; // fg
-      r[j++] = (fcol >>  0) & 0xFF; // fb
+      r[j++] = (fcol) & 0xFF; // fb
 
       r[j++] = in.normals[3*i + 0]; // nx
       r[j++] = in.normals[3*i + 1]; // ny
@@ -13135,6 +13178,7 @@ public class PGraphicsOpenGL extends PGraphics {
         }
       }
 
+      @Override
       public void begin(int type) {
         cacheIndex = cache.getLast();
         if (firstPolyIndexCache == -1) {
@@ -13153,6 +13197,7 @@ public class PGraphicsOpenGL extends PGraphics {
         else if (type == PGL.TRIANGLES) primitive = TRIANGLES;
       }
 
+      @Override
       public void end() {
         if (PGL.MAX_VERTEX_INDEX1 <= vertFirst + vertCount) {
           // We need a new index block for the new batch of
@@ -13228,6 +13273,7 @@ public class PGraphicsOpenGL extends PGraphics {
                             vertFirst + vertOffset + tessIdx2);
       }
 
+      @Override
       public void vertex(Object data) {
         if (data instanceof double[]) {
           double[] d = (double[]) data;