propane 3.9.0-java → 3.10.0-java

data/lib/java/processing/opengl/VertexBuffer.java

@@ -0,0 +1,88 @@
+/* -*- 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
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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.opengl.PGraphicsOpenGL.GLResourceVertexBuffer;
+
+// TODO: need to combine with PGraphicsOpenGL.VertexAttribute
+public class VertexBuffer {
+  static protected final int INIT_VERTEX_BUFFER_SIZE  = 256;
+  static protected final int INIT_INDEX_BUFFER_SIZE   = 512;
+
+  public int glId;
+  int target;
+  int elementSize;
+  int ncoords;
+  boolean index;
+
+  protected PGL pgl;                // The interface between Processing and OpenGL.
+  protected int context;            // The context that created this texture.
+  private GLResourceVertexBuffer glres;
+
+  VertexBuffer(PGraphicsOpenGL pg, int target, int ncoords, int esize) {
+    this(pg, target, ncoords, esize, false);
+  }
+
+  VertexBuffer(PGraphicsOpenGL pg, int target, int ncoords, int esize, boolean index) {
+    pgl = pg.pgl;
+    context = pgl.createEmptyContext();
+
+    this.target = target;
+    this.ncoords = ncoords;
+    this.elementSize = esize;
+    this.index = index;
+    create();
+    init();
+  }
+
+  protected final void create() {
+    context = pgl.getCurrentContext();
+    glres = new GLResourceVertexBuffer(this);
+  }
+
+  protected final void init() {
+    int size = index ? ncoords * INIT_INDEX_BUFFER_SIZE * elementSize :
+                       ncoords * INIT_VERTEX_BUFFER_SIZE * elementSize;
+    pgl.bindBuffer(target, glId);
+    pgl.bufferData(target, size, null, PGL.STATIC_DRAW);
+  }
+
+  protected void dispose() {
+    if (glres != null) {
+      glres.dispose();
+      glId = 0;
+      glres = null;
+    }
+  }
+
+  protected boolean contextIsOutdated() {
+    boolean outdated = !pgl.contextIsCurrent(context);
+    if (outdated) {
+      dispose();
+    }
+    return outdated;
+  }
+
+}

data/lib/java/processing/opengl/cursors/license.txt

@@ -0,0 +1,27 @@
+These files are based on the DMZ Cursors package, 
+used with permission from Jakub Steiner <jimmac@gmail.com> 
+11 September 2015
+
+
+The MIT License (MIT)
+
+Copyright (c) 2006 Jakub Steiner <jimmac@novell.com>
+Copyright (c) 2006 Novell, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/java/processing/opengl/shaders/ColorFrag.glsl

@@ -0,0 +1,32 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-15 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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
+*/
+
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+varying vec4 vertColor;
+
+void main() {
+  gl_FragColor = vertColor;
+}

data/lib/java/processing/opengl/shaders/ColorVert.glsl

@@ -0,0 +1,34 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-15 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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
+*/
+
+uniform mat4 transformMatrix;
+
+attribute vec4 position;
+attribute vec4 color;
+
+varying vec4 vertColor;
+
+void main() {
+  gl_Position = transformMatrix * position;
+    
+  vertColor = color;
+}

data/lib/java/processing/opengl/shaders/LightFrag.glsl

@@ -0,0 +1,33 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-15 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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
+*/
+ 
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+varying vec4 vertColor;
+varying vec4 backVertColor;
+
+void main() {
+  gl_FragColor = gl_FrontFacing ? vertColor : backVertColor;
+}

data/lib/java/processing/opengl/shaders/LightVert.glsl

@@ -0,0 +1,151 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-15 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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
+*/
+
+uniform mat4 modelviewMatrix;
+uniform mat4 transformMatrix;
+uniform mat3 normalMatrix;
+
+uniform int lightCount;
+uniform vec4 lightPosition[8];
+uniform vec3 lightNormal[8];
+uniform vec3 lightAmbient[8];
+uniform vec3 lightDiffuse[8];
+uniform vec3 lightSpecular[8];      
+uniform vec3 lightFalloff[8];
+uniform vec2 lightSpot[8];
+
+attribute vec4 position;
+attribute vec4 color;
+attribute vec3 normal;
+
+attribute vec4 ambient;
+attribute vec4 specular;
+attribute vec4 emissive;
+attribute float shininess;
+
+varying vec4 vertColor;
+varying vec4 backVertColor;
+
+const float zero_float = 0.0;
+const float one_float = 1.0;
+const vec3 zero_vec3 = vec3(0);
+
+float falloffFactor(vec3 lightPos, vec3 vertPos, vec3 coeff) {
+  vec3 lpv = lightPos - vertPos;
+  vec3 dist = vec3(one_float);
+  dist.z = dot(lpv, lpv);
+  dist.y = sqrt(dist.z);
+  return one_float / dot(dist, coeff);
+}
+
+float spotFactor(vec3 lightPos, vec3 vertPos, vec3 lightNorm, float minCos, float spotExp) {
+  vec3 lpv = normalize(lightPos - vertPos);
+  vec3 nln = -one_float * lightNorm;
+  float spotCos = dot(nln, lpv);
+  return spotCos <= minCos ? zero_float : pow(spotCos, spotExp);
+}
+
+float lambertFactor(vec3 lightDir, vec3 vecNormal) {
+  return max(zero_float, dot(lightDir, vecNormal));
+}
+
+float blinnPhongFactor(vec3 lightDir, vec3 vertPos, vec3 vecNormal, float shine) {
+  vec3 np = normalize(vertPos);
+  vec3 ldp = normalize(lightDir - np);
+  return pow(max(zero_float, dot(ldp, vecNormal)), shine);
+}
+
+void main() {
+  // Vertex in clip coordinates
+  gl_Position = transformMatrix * position;
+    
+  // Vertex in eye coordinates
+  vec3 ecVertex = vec3(modelviewMatrix * position);
+  
+  // Normal vector in eye coordinates
+  vec3 ecNormal = normalize(normalMatrix * normal);
+  vec3 ecNormalInv = ecNormal * -one_float;
+  
+  // Light calculations
+  vec3 totalAmbient = vec3(0, 0, 0);
+  
+  vec3 totalFrontDiffuse = vec3(0, 0, 0);
+  vec3 totalFrontSpecular = vec3(0, 0, 0);
+  
+  vec3 totalBackDiffuse = vec3(0, 0, 0);
+  vec3 totalBackSpecular = vec3(0, 0, 0);
+  
+  for (int i = 0; i < 8; i++) {
+    if (lightCount == i) break;
+    
+    vec3 lightPos = lightPosition[i].xyz;
+    bool isDir = lightPosition[i].w < one_float;
+    float spotCos = lightSpot[i].x;
+    float spotExp = lightSpot[i].y;
+    
+    vec3 lightDir;
+    float falloff;    
+    float spotf;
+      
+    if (isDir) {
+      falloff = one_float;
+      lightDir = -one_float * lightNormal[i];
+    } else {
+      falloff = falloffFactor(lightPos, ecVertex, lightFalloff[i]);  
+      lightDir = normalize(lightPos - ecVertex);
+    }
+  
+    spotf = spotExp > zero_float ? spotFactor(lightPos, ecVertex, lightNormal[i], 
+                                              spotCos, spotExp) 
+                                 : one_float;
+    
+    if (any(greaterThan(lightAmbient[i], zero_vec3))) {
+      totalAmbient       += lightAmbient[i] * falloff;
+    }
+    
+    if (any(greaterThan(lightDiffuse[i], zero_vec3))) {
+      totalFrontDiffuse  += lightDiffuse[i] * falloff * spotf * 
+                            lambertFactor(lightDir, ecNormal);
+      totalBackDiffuse   += lightDiffuse[i] * falloff * spotf * 
+                            lambertFactor(lightDir, ecNormalInv);
+    }
+    
+    if (any(greaterThan(lightSpecular[i], zero_vec3))) {
+      totalFrontSpecular += lightSpecular[i] * falloff * spotf * 
+                            blinnPhongFactor(lightDir, ecVertex, ecNormal, shininess);
+      totalBackSpecular  += lightSpecular[i] * falloff * spotf * 
+                            blinnPhongFactor(lightDir, ecVertex, ecNormalInv, shininess);
+    }     
+  }    
+
+  // Calculating final color as result of all lights (plus emissive term).
+  // Transparency is determined exclusively by the diffuse component.
+  vertColor =     vec4(totalAmbient, 0) * ambient + 
+                  vec4(totalFrontDiffuse, 1) * color + 
+                  vec4(totalFrontSpecular, 0) * specular + 
+                  vec4(emissive.rgb, 0);
+              
+  backVertColor = vec4(totalAmbient, 0) * ambient + 
+                  vec4(totalBackDiffuse, 1) * color + 
+                  vec4(totalBackSpecular, 0) * specular + 
+                  vec4(emissive.rgb, 0);
+}

data/lib/java/processing/opengl/shaders/LineFrag.glsl

@@ -0,0 +1,32 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-15 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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
+*/
+ 
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+varying vec4 vertColor;
+
+void main() {
+  gl_FragColor = vertColor;
+}

data/lib/java/processing/opengl/shaders/LineVert.glsl

@@ -0,0 +1,100 @@
+/*
+  Part of the Processing project - http://processing.org
+
+  Copyright (c) 2012-15 The Processing Foundation
+  Copyright (c) 2004-12 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation, version 2.1.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General
+  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
+*/
+
+#define PROCESSING_LINE_SHADER
+
+uniform mat4 modelviewMatrix;
+uniform mat4 projectionMatrix;
+
+uniform vec4 viewport;
+uniform int perspective;
+uniform vec3 scale;
+
+attribute vec4 position;
+attribute vec4 color;
+attribute vec4 direction;
+
+varying vec4 vertColor;
+  
+void main() {
+  vec4 posp = modelviewMatrix * position;
+  vec4 posq = modelviewMatrix * (position + vec4(direction.xyz, 0));
+
+  // Moving vertices slightly toward the camera
+  // to avoid depth-fighting with the fill triangles.
+  // Discussed here:
+  // http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=252848  
+  posp.xyz = posp.xyz * scale;
+  posq.xyz = posq.xyz * scale;
+
+  vec4 p = projectionMatrix * posp;
+  vec4 q = projectionMatrix * posq;
+
+  // formula to convert from clip space (range -1..1) to screen space (range 0..[width or height])
+  // screen_p = (p.xy/p.w + <1,1>) * 0.5 * viewport.zw
+
+  // prevent division by W by transforming the tangent formula (div by 0 causes
+  // the line to disappear, see https://github.com/processing/processing/issues/5183)
+  // t = screen_q - screen_p
+  //
+  // tangent is normalized and we don't care which direction it points to (+-)
+  // t = +- normalize( screen_q - screen_p )
+  // t = +- normalize( (q.xy/q.w+<1,1>)*0.5*viewport.zw - (p.xy/p.w+<1,1>)*0.5*viewport.zw )
+  //
+  // extract common factor, <1,1> - <1,1> cancels out
+  // t = +- normalize( (q.xy/q.w - p.xy/p.w) * 0.5 * viewport.zw )
+  //
+  // convert to common divisor
+  // t = +- normalize( ((q.xy*p.w - p.xy*q.w) / (p.w*q.w)) * 0.5 * viewport.zw )
+  //
+  // remove the common scalar divisor/factor, not needed due to normalize and +-
+  // (keep viewport - can't remove because it has different components for x and y
+  //  and corrects for aspect ratio, see https://github.com/processing/processing/issues/5181)
+  // t = +- normalize( (q.xy*p.w - p.xy*q.w) * viewport.zw )
+
+  vec2 tangent = (q.xy*p.w - p.xy*q.w) * viewport.zw;
+
+  // don't normalize zero vector (line join triangles and lines perpendicular to the eye plane)
+  tangent = length(tangent) == 0.0 ? vec2(0.0, 0.0) : normalize(tangent);
+
+  // flip tangent to normal (it's already normalized)
+  vec2 normal = vec2(-tangent.y, tangent.x);
+
+  float thickness = direction.w;
+  vec2 offset = normal * thickness;
+
+  // Perspective ---
+  // convert from world to clip by multiplying with projection scaling factor
+  // to get the right thickness (see https://github.com/processing/processing/issues/5182)
+  // invert Y, projections in Processing invert Y
+  vec2 perspScale = (projectionMatrix * vec4(1, -1, 0, 0)).xy;
+
+  // No Perspective ---
+  // multiply by W (to cancel out division by W later in the pipeline) and
+  // convert from screen to clip (derived from clip to screen above)
+  vec2 noPerspScale = p.w / (0.5 * viewport.zw);
+
+  gl_Position.xy = p.xy + offset.xy * mix(noPerspScale, perspScale, float(perspective > 0));
+  gl_Position.zw = p.zw;
+
+  vertColor = color;
+}