picrate 0.7.0-java → 0.8.0-java

data/src/main/java/processing/opengl/PShader.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.*;
@@ -33,132 +32,132 @@ import java.nio.IntBuffer;
 import java.util.HashMap;
 
 /**
- * This class encapsulates a GLSL shader program, including a vertex
- * and a fragment shader. Based on the GLSLShader class from GLGraphics, which
- * in turn was originally based in the code by JohnG:
+ * This class encapsulates a GLSL shader program, including a vertex and a
+ * fragment shader. Based on the GLSLShader class from GLGraphics, which in turn
+ * was originally based in the code by JohnG:
  * http://processing.org/discourse/beta/num_1159494801.html
  *
  * @webref rendering:shaders
  */
 public class PShader implements PConstants {
 
-    /**
-     *
-     */
-    static protected final int POINT    = 0;
-
-    /**
-     *
-     */
-    static protected final int LINE     = 1;
-
-    /**
-     *
-     */
-    static protected final int POLY     = 2;
-
-    /**
-     *
-     */
-    static protected final int COLOR    = 3;
-
-    /**
-     *
-     */
-    static protected final int LIGHT    = 4;
-
-    /**
-     *
-     */
-    static protected final int TEXTURE  = 5;
-
-    /**
-     *
-     */
-    static protected final int TEXLIGHT = 6;
-
-    /**
-     *
-     */
-    static protected String pointShaderAttrRegexp =
-    "attribute *vec2 *offset";
-
-    /**
-     *
-     */
-    static protected String pointShaderInRegexp =
-    "in *vec2 *offset;";
-
-    /**
-     *
-     */
-    static protected String lineShaderAttrRegexp =
-    "attribute *vec4 *direction";
-
-    /**
-     *
-     */
-    static protected String lineShaderInRegexp =
-    "in *vec4 *direction";
-
-    /**
-     *
-     */
-    static protected String pointShaderDefRegexp =
-    "#define *PROCESSING_POINT_SHADER";
-
-    /**
-     *
-     */
-    static protected String lineShaderDefRegexp =
-    "#define *PROCESSING_LINE_SHADER";
-
-    /**
-     *
-     */
-    static protected String colorShaderDefRegexp =
-    "#define *PROCESSING_COLOR_SHADER";
-
-    /**
-     *
-     */
-    static protected String lightShaderDefRegexp =
-    "#define *PROCESSING_LIGHT_SHADER";
-
-    /**
-     *
-     */
-    static protected String texShaderDefRegexp =
-    "#define *PROCESSING_TEXTURE_SHADER";
-
-    /**
-     *
-     */
-    static protected String texlightShaderDefRegexp =
-    "#define *PROCESSING_TEXLIGHT_SHADER";
-
-    /**
-     *
-     */
-    static protected String polyShaderDefRegexp =
-    "#define *PROCESSING_POLYGON_SHADER";
-
-    /**
-     *
-     */
-    static protected String triShaderAttrRegexp =
-    "#define *PROCESSING_TRIANGLES_SHADER";
-
-    /**
-     *
-     */
-    static protected String quadShaderAttrRegexp =
-    "#define *PROCESSING_QUADS_SHADER";
-
-    /**
-     *
-     */
-    protected PApplet parent;
+  /**
+   *
+   */
+  static protected final int POINT = 0;
+
+  /**
+   *
+   */
+  static protected final int LINE = 1;
+
+  /**
+   *
+   */
+  static protected final int POLY = 2;
+
+  /**
+   *
+   */
+  static protected final int COLOR = 3;
+
+  /**
+   *
+   */
+  static protected final int LIGHT = 4;
+
+  /**
+   *
+   */
+  static protected final int TEXTURE = 5;
+
+  /**
+   *
+   */
+  static protected final int TEXLIGHT = 6;
+
+  /**
+   *
+   */
+  static protected String pointShaderAttrRegexp
+    = "attribute *vec2 *offset";
+
+  /**
+   *
+   */
+  static protected String pointShaderInRegexp
+    = "in *vec2 *offset;";
+
+  /**
+   *
+   */
+  static protected String lineShaderAttrRegexp
+    = "attribute *vec4 *direction";
+
+  /**
+   *
+   */
+  static protected String lineShaderInRegexp
+    = "in *vec4 *direction";
+
+  /**
+   *
+   */
+  static protected String pointShaderDefRegexp
+    = "#define *PROCESSING_POINT_SHADER";
+
+  /**
+   *
+   */
+  static protected String lineShaderDefRegexp
+    = "#define *PROCESSING_LINE_SHADER";
+
+  /**
+   *
+   */
+  static protected String colorShaderDefRegexp
+    = "#define *PROCESSING_COLOR_SHADER";
+
+  /**
+   *
+   */
+  static protected String lightShaderDefRegexp
+    = "#define *PROCESSING_LIGHT_SHADER";
+
+  /**
+   *
+   */
+  static protected String texShaderDefRegexp
+    = "#define *PROCESSING_TEXTURE_SHADER";
+
+  /**
+   *
+   */
+  static protected String texlightShaderDefRegexp
+    = "#define *PROCESSING_TEXLIGHT_SHADER";
+
+  /**
+   *
+   */
+  static protected String polyShaderDefRegexp
+    = "#define *PROCESSING_POLYGON_SHADER";
+
+  /**
+   *
+   */
+  static protected String triShaderAttrRegexp
+    = "#define *PROCESSING_TRIANGLES_SHADER";
+
+  /**
+   *
+   */
+  static protected String quadShaderAttrRegexp
+    = "#define *PROCESSING_QUADS_SHADER";
+
+  /**
+   *
+   */
+  protected PApplet parent;
   // The main renderer associated to the parent PApplet.
   //protected PGraphicsOpenGL pgMain;
   // We need a reference to the renderer since a shader might
@@ -166,305 +165,298 @@ public class PShader implements PConstants {
   // (the one corresponding to the main surface, or other offscreen
   // renderers).
 
-    /**
-     *
-     */
+  /**
+   *
+   */
   protected PGraphicsOpenGL primaryPG;
 
-    /**
-     *
-     */
-    protected PGraphicsOpenGL currentPG;
+  /**
+   *
+   */
+  protected PGraphicsOpenGL currentPG;
 
-    /**
-     *
-     */
-    protected PGL pgl;
+  /**
+   *
+   */
+  protected PGL pgl;
 
-    /**
-     *
-     */
-    protected int context;      // The context that created this shader.
+  /**
+   *
+   */
+  protected int context;      // The context that created this shader.
 
   // The shader type: POINT, LINE, POLY, etc.
-
-    /**
-     *
-     */
+  /**
+   *
+   */
   protected int type;
 
-    /**
-     *
-     */
-    public int glProgram;
+  /**
+   *
+   */
+  public int glProgram;
 
-    /**
-     *
-     */
-    public int glVertex;
+  /**
+   *
+   */
+  public int glVertex;
 
-    /**
-     *
-     */
-    public int glFragment;
+  /**
+   *
+   */
+  public int glFragment;
   private GLResourceShader glres;
 
-    /**
-     *
-     */
-    protected URL vertexURL;
-
-    /**
-     *
-     */
-    protected URL fragmentURL;
-
-    /**
-     *
-     */
-    protected String vertexFilename;
-
-    /**
-     *
-     */
-    protected String fragmentFilename;
-
-    /**
-     *
-     */
-    protected String[] vertexShaderSource;
-
-    /**
-     *
-     */
-    protected String[] fragmentShaderSource;
-
-    /**
-     *
-     */
-    protected boolean bound;
-
-    /**
-     *
-     */
-    protected HashMap<String, UniformValue> uniformValues = null;
-
-    /**
-     *
-     */
-    protected HashMap<Integer, Texture> textures;
-
-    /**
-     *
-     */
-    protected HashMap<Integer, Integer> texUnits;
+  /**
+   *
+   */
+  protected URL vertexURL;
 
-  // Direct buffers to pass shader data to GL
+  /**
+   *
+   */
+  protected URL fragmentURL;
+
+  /**
+   *
+   */
+  protected String vertexFilename;
+
+  /**
+   *
+   */
+  protected String fragmentFilename;
+
+  /**
+   *
+   */
+  protected String[] vertexShaderSource;
+
+  /**
+   *
+   */
+  protected String[] fragmentShaderSource;
+
+  /**
+   *
+   */
+  protected boolean bound;
+
+  /**
+   *
+   */
+  protected HashMap<String, UniformValue> uniformValues = null;
 
-    /**
-     *
-     */
+  /**
+   *
+   */
+  protected HashMap<Integer, Texture> textures;
+
+  /**
+   *
+   */
+  protected HashMap<Integer, Integer> texUnits;
+
+  // Direct buffers to pass shader data to GL
+  /**
+   *
+   */
   protected IntBuffer intBuffer;
 
-    /**
-     *
-     */
-    protected FloatBuffer floatBuffer;
+  /**
+   *
+   */
+  protected FloatBuffer floatBuffer;
 
-    /**
-     *
-     */
-    protected boolean loadedAttributes = false;
+  /**
+   *
+   */
+  protected boolean loadedAttributes = false;
 
-    /**
-     *
-     */
-    protected boolean loadedUniforms = false;
+  /**
+   *
+   */
+  protected boolean loadedUniforms = false;
 
   // Uniforms common to all shader types
-
-    /**
-     *
-     */
+  /**
+   *
+   */
   protected int transformMatLoc;
 
-    /**
-     *
-     */
-    protected int modelviewMatLoc;
+  /**
+   *
+   */
+  protected int modelviewMatLoc;
 
-    /**
-     *
-     */
-    protected int projectionMatLoc;
+  /**
+   *
+   */
+  protected int projectionMatLoc;
 
-    /**
-     *
-     */
-    protected int ppixelsLoc;
+  /**
+   *
+   */
+  protected int ppixelsLoc;
 
-    /**
-     *
-     */
-    protected int ppixelsUnit;
+  /**
+   *
+   */
+  protected int ppixelsUnit;
 
-    /**
-     *
-     */
-    protected int viewportLoc;
+  /**
+   *
+   */
+  protected int viewportLoc;
 
-    /**
-     *
-     */
-    protected int resolutionLoc;
+  /**
+   *
+   */
+  protected int resolutionLoc;
 
   // Uniforms only for lines and points
-
-    /**
-     *
-     */
+  /**
+   *
+   */
   protected int perspectiveLoc;
 
-    /**
-     *
-     */
-    protected int scaleLoc;
+  /**
+   *
+   */
+  protected int scaleLoc;
 
   // Lighting uniforms
-
-    /**
-     *
-     */
+  /**
+   *
+   */
   protected int lightCountLoc;
 
-    /**
-     *
-     */
-    protected int lightPositionLoc;
-
-    /**
-     *
-     */
-    protected int lightNormalLoc;
-
-    /**
-     *
-     */
-    protected int lightAmbientLoc;
-
-    /**
-     *
-     */
-    protected int lightDiffuseLoc;
-
-    /**
-     *
-     */
-    protected int lightSpecularLoc;
-
-    /**
-     *
-     */
-    protected int lightFalloffLoc;
-
-    /**
-     *
-     */
-    protected int lightSpotLoc;
+  /**
+   *
+   */
+  protected int lightPositionLoc;
 
-  // Texturing uniforms
+  /**
+   *
+   */
+  protected int lightNormalLoc;
 
-    /**
-     *
-     */
+  /**
+   *
+   */
+  protected int lightAmbientLoc;
+
+  /**
+   *
+   */
+  protected int lightDiffuseLoc;
+
+  /**
+   *
+   */
+  protected int lightSpecularLoc;
+
+  /**
+   *
+   */
+  protected int lightFalloffLoc;
+
+  /**
+   *
+   */
+  protected int lightSpotLoc;
+
+  // Texturing uniforms
+  /**
+   *
+   */
   protected Texture texture;
 
-    /**
-     *
-     */
-    protected int texUnit;
+  /**
+   *
+   */
+  protected int texUnit;
 
-    /**
-     *
-     */
-    protected int textureLoc;
+  /**
+   *
+   */
+  protected int textureLoc;
 
-    /**
-     *
-     */
-    protected int texMatrixLoc;
+  /**
+   *
+   */
+  protected int texMatrixLoc;
 
-    /**
-     *
-     */
-    protected int texOffsetLoc;
+  /**
+   *
+   */
+  protected int texOffsetLoc;
 
-    /**
-     *
-     */
-    protected float[] tcmat;
+  /**
+   *
+   */
+  protected float[] tcmat;
 
   // Vertex attributes
-
-    /**
-     *
-     */
+  /**
+   *
+   */
   protected int vertexLoc;
 
-    /**
-     *
-     */
-    protected int colorLoc;
-
-    /**
-     *
-     */
-    protected int normalLoc;
-
-    /**
-     *
-     */
-    protected int texCoordLoc;
-
-    /**
-     *
-     */
-    protected int normalMatLoc;
-
-    /**
-     *
-     */
-    protected int directionLoc;
-
-    /**
-     *
-     */
-    protected int offsetLoc;
-
-    /**
-     *
-     */
-    protected int ambientLoc;
-
-    /**
-     *
-     */
-    protected int specularLoc;
-
-    /**
-     *
-     */
-    protected int emissiveLoc;
-
-    /**
-     *
-     */
-    protected int shininessLoc;
-
-    /**
-     *
-     */
-    public PShader() {
+  /**
+   *
+   */
+  protected int colorLoc;
+
+  /**
+   *
+   */
+  protected int normalLoc;
+
+  /**
+   *
+   */
+  protected int texCoordLoc;
+
+  /**
+   *
+   */
+  protected int normalMatLoc;
+
+  /**
+   *
+   */
+  protected int directionLoc;
+
+  /**
+   *
+   */
+  protected int offsetLoc;
+
+  /**
+   *
+   */
+  protected int ambientLoc;
+
+  /**
+   *
+   */
+  protected int specularLoc;
+
+  /**
+   *
+   */
+  protected int emissiveLoc;
+
+  /**
+   *
+   */
+  protected int shininessLoc;
+
+  /**
+   *
+   */
+  public PShader() {
     parent = null;
     pgl = null;
     context = -1;
@@ -486,22 +478,20 @@ public class PShader implements PConstants {
     type = -1;
   }
 
-    /**
-     *
-     * @param parent
-     */
-    public PShader(PApplet parent) {
+  /**
+   *
+   * @param parent
+   */
+  public PShader(PApplet parent) {
     this();
     this.parent = parent;
-    primaryPG = (PGraphicsOpenGL)parent.g;
+    primaryPG = (PGraphicsOpenGL) parent.g;
     pgl = primaryPG.pgl;
     context = pgl.createEmptyContext();
   }
 
-
   /**
-   * Creates a shader program using the specified vertex and fragment
-   * shaders.
+   * Creates a shader program using the specified vertex and fragment shaders.
    *
    * @param parent the parent program
    * @param vertFilename name of the vertex shader
@@ -509,7 +499,7 @@ public class PShader implements PConstants {
    */
   public PShader(PApplet parent, String vertFilename, String fragFilename) {
     this.parent = parent;
-    primaryPG = (PGraphicsOpenGL)parent.g;
+    primaryPG = (PGraphicsOpenGL) parent.g;
     pgl = primaryPG.pgl;
 
     this.vertexURL = null;
@@ -534,22 +524,21 @@ public class PShader implements PConstants {
       type = fragType;
     } else if (fragType == -1) {
       type = vertType;
-    } else if (fragType == vertType)  {
+    } else if (fragType == vertType) {
       type = vertType;
     } else {
       PGraphics.showWarning(PGraphicsOpenGL.INCONSISTENT_SHADER_TYPES);
     }
   }
 
-
   /**
-     * @param parent
+   * @param parent
    * @param vertURL network location of the vertex shader
    * @param fragURL network location of the fragment shader
    */
   public PShader(PApplet parent, URL vertURL, URL fragURL) {
     this.parent = parent;
-    primaryPG = (PGraphicsOpenGL)parent.g;
+    primaryPG = (PGraphicsOpenGL) parent.g;
     pgl = primaryPG.pgl;
 
     this.vertexURL = vertURL;
@@ -574,22 +563,22 @@ public class PShader implements PConstants {
       type = fragType;
     } else if (fragType == -1) {
       type = vertType;
-    } else if (fragType == vertType)  {
+    } else if (fragType == vertType) {
       type = vertType;
     } else {
       PGraphics.showWarning(PGraphicsOpenGL.INCONSISTENT_SHADER_TYPES);
     }
   }
 
-    /**
-     *
-     * @param parent
-     * @param vertSource
-     * @param fragSource
-     */
-    public PShader(PApplet parent, String[] vertSource, String[] fragSource) {
+  /**
+   *
+   * @param parent
+   * @param vertSource
+   * @param fragSource
+   */
+  public PShader(PApplet parent, String[] vertSource, String[] fragSource) {
     this.parent = parent;
-    primaryPG = (PGraphicsOpenGL)parent.g;
+    primaryPG = (PGraphicsOpenGL) parent.g;
     pgl = primaryPG.pgl;
 
     this.vertexURL = null;
@@ -614,66 +603,65 @@ public class PShader implements PConstants {
       type = fragType;
     } else if (fragType == -1) {
       type = vertType;
-    } else if (fragType == vertType)  {
+    } else if (fragType == vertType) {
       type = vertType;
     } else {
       PGraphics.showWarning(PGraphicsOpenGL.INCONSISTENT_SHADER_TYPES);
     }
   }
 
-    /**
-     *
-     * @param vertFilename
-     */
-    public void setVertexShader(String vertFilename) {
+  /**
+   *
+   * @param vertFilename
+   */
+  public void setVertexShader(String vertFilename) {
     this.vertexFilename = vertFilename;
     vertexShaderSource = pgl.loadVertexShader(vertFilename);
   }
 
-    /**
-     *
-     * @param vertURL
-     */
-    public void setVertexShader(URL vertURL) {
+  /**
+   *
+   * @param vertURL
+   */
+  public void setVertexShader(URL vertURL) {
     this.vertexURL = vertURL;
     vertexShaderSource = pgl.loadVertexShader(vertURL);
   }
 
-    /**
-     *
-     * @param vertSource
-     */
-    public void setVertexShader(String[] vertSource) {
+  /**
+   *
+   * @param vertSource
+   */
+  public void setVertexShader(String[] vertSource) {
     vertexShaderSource = vertSource;
   }
 
-    /**
-     *
-     * @param fragFilename
-     */
-    public void setFragmentShader(String fragFilename) {
+  /**
+   *
+   * @param fragFilename
+   */
+  public void setFragmentShader(String fragFilename) {
     this.fragmentFilename = fragFilename;
     fragmentShaderSource = pgl.loadFragmentShader(fragFilename);
   }
 
-    /**
-     *
-     * @param fragURL
-     */
-    public void setFragmentShader(URL fragURL) {
+  /**
+   *
+   * @param fragURL
+   */
+  public void setFragmentShader(URL fragURL) {
     this.fragmentURL = fragURL;
     fragmentShaderSource = pgl.loadFragmentShader(fragURL);
   }
 
-    /**
-     *
-     * @param fragSource
-     */
-    public void setFragmentShader(String[] fragSource) {
+  /**
+   *
+   * @param fragSource
+   */
+  public void setFragmentShader(String[] fragSource) {
     fragmentShaderSource = fragSource;
   }
 
-
   /**
    * Initializes (if needed) and binds the shader program.
    */
@@ -686,15 +674,18 @@ public class PShader implements PConstants {
       bindTextures();
     }
 
-    if (hasType()) bindTyped();
+    if (hasType()) {
+      bindTyped();
+    }
   }
 
-
   /**
    * Unbinds the shader program.
    */
   public void unbind() {
-    if (hasType()) unbindTyped();
+    if (hasType()) {
+      unbindTyped();
+    }
 
     if (bound) {
       unbindTextures();
@@ -703,10 +694,10 @@ public class PShader implements PConstants {
     }
   }
 
-
   /**
    * Returns true if the shader is bound, false otherwise.
-     * @return 
+   *
+   * @return
    */
   public boolean bound() {
     return bound;
@@ -719,149 +710,152 @@ public class PShader implements PConstants {
    * @param x first component of the variable to modify
    */
   public void set(String name, int x) {
-    setUniformImpl(name, UniformValue.INT1, new int[] { x });
+    setUniformImpl(name, UniformValue.INT1, new int[]{x});
   }
 
   /**
-     * @param name
-   * @param y second component of the variable to modify. The variable has to be declared with an array/vector type in the shader (i.e.: int[2], vec2)
-     * @param x
+   * @param name
+   * @param y second component of the variable to modify. The variable has to be
+   * declared with an array/vector type in the shader (i.e.: int[2], vec2)
+   * @param x
    */
   public void set(String name, int x, int y) {
-    setUniformImpl(name, UniformValue.INT2, new int[] { x, y });
+    setUniformImpl(name, UniformValue.INT2, new int[]{x, y});
   }
 
   /**
-     * @param name
-   * @param z third component of the variable to modify. The variable has to be declared with an array/vector type in the shader (i.e.: int[3], vec3)
-     * @param x
-     * @param y
+   * @param name
+   * @param z third component of the variable to modify. The variable has to be
+   * declared with an array/vector type in the shader (i.e.: int[3], vec3)
+   * @param x
+   * @param y
    */
   public void set(String name, int x, int y, int z) {
-    setUniformImpl(name, UniformValue.INT3, new int[] { x, y, z });
+    setUniformImpl(name, UniformValue.INT3, new int[]{x, y, z});
   }
 
   /**
-     * @param name
-     * @param x
-   * @param w fourth component of the variable to modify. The variable has to be declared with an array/vector type in the shader (i.e.: int[4], vec4)
-     * @param z
-     * @param y
+   * @param name
+   * @param x
+   * @param w fourth component of the variable to modify. The variable has to be
+   * declared with an array/vector type in the shader (i.e.: int[4], vec4)
+   * @param z
+   * @param y
    */
   public void set(String name, int x, int y, int z, int w) {
-    setUniformImpl(name, UniformValue.INT4, new int[] { x, y, z, w });
+    setUniformImpl(name, UniformValue.INT4, new int[]{x, y, z, w});
   }
 
-    /**
-     *
-     * @param name
-     * @param x
-     */
-    public void set(String name, float x) {
-    setUniformImpl(name, UniformValue.FLOAT1, new float[] { x });
+  /**
+   *
+   * @param name
+   * @param x
+   */
+  public void set(String name, float x) {
+    setUniformImpl(name, UniformValue.FLOAT1, new float[]{x});
   }
 
-    /**
-     *
-     * @param name
-     * @param x
-     * @param y
-     */
-    public void set(String name, float x, float y) {
-    setUniformImpl(name, UniformValue.FLOAT2, new float[] { x, y });
+  /**
+   *
+   * @param name
+   * @param x
+   * @param y
+   */
+  public void set(String name, float x, float y) {
+    setUniformImpl(name, UniformValue.FLOAT2, new float[]{x, y});
   }
 
-    /**
-     *
-     * @param name
-     * @param x
-     * @param y
-     * @param z
-     */
-    public void set(String name, float x, float y, float z) {
-    setUniformImpl(name, UniformValue.FLOAT3, new float[] { x, y, z });
+  /**
+   *
+   * @param name
+   * @param x
+   * @param y
+   * @param z
+   */
+  public void set(String name, float x, float y, float z) {
+    setUniformImpl(name, UniformValue.FLOAT3, new float[]{x, y, z});
   }
 
-    /**
-     *
-     * @param name
-     * @param x
-     * @param y
-     * @param z
-     * @param w
-     */
-    public void set(String name, float x, float y, float z, float w) {
-    setUniformImpl(name, UniformValue.FLOAT4, new float[] { x, y, z, w });
+  /**
+   *
+   * @param name
+   * @param x
+   * @param y
+   * @param z
+   * @param w
+   */
+  public void set(String name, float x, float y, float z, float w) {
+    setUniformImpl(name, UniformValue.FLOAT4, new float[]{x, y, z, w});
   }
 
   /**
-     * @param name
-   * @param vec modifies all the components of an array/vector uniform variable. PVector can only be used if the type of the variable is vec3.
+   * @param name
+   * @param vec modifies all the components of an array/vector uniform variable.
+   * PVector can only be used if the type of the variable is vec3.
    */
   public void set(String name, PVector vec) {
     setUniformImpl(name, UniformValue.FLOAT3,
-                   new float[] { vec.x, vec.y, vec.z });
+      new float[]{vec.x, vec.y, vec.z});
   }
 
-    /**
-     *
-     * @param name
-     * @param x
-     */
-    public void set(String name, boolean x) {
-    setUniformImpl(name, UniformValue.INT1, new int[] { (x)?1:0 });
+  /**
+   *
+   * @param name
+   * @param x
+   */
+  public void set(String name, boolean x) {
+    setUniformImpl(name, UniformValue.INT1, new int[]{(x) ? 1 : 0});
   }
 
-    /**
-     *
-     * @param name
-     * @param x
-     * @param y
-     */
-    public void set(String name, boolean x, boolean y) {
+  /**
+   *
+   * @param name
+   * @param x
+   * @param y
+   */
+  public void set(String name, boolean x, boolean y) {
     setUniformImpl(name, UniformValue.INT2,
-                   new int[] { (x)?1:0, (y)?1:0 });
+      new int[]{(x) ? 1 : 0, (y) ? 1 : 0});
   }
 
-    /**
-     *
-     * @param name
-     * @param x
-     * @param y
-     * @param z
-     */
-    public void set(String name, boolean x, boolean y, boolean z) {
+  /**
+   *
+   * @param name
+   * @param x
+   * @param y
+   * @param z
+   */
+  public void set(String name, boolean x, boolean y, boolean z) {
     setUniformImpl(name, UniformValue.INT3,
-                   new int[] { (x)?1:0, (y)?1:0, (z)?1:0 });
-  }
-
-    /**
-     *
-     * @param name
-     * @param x
-     * @param y
-     * @param z
-     * @param w
-     */
-    public void set(String name, boolean x, boolean y, boolean z, boolean w) {
+      new int[]{(x) ? 1 : 0, (y) ? 1 : 0, (z) ? 1 : 0});
+  }
+
+  /**
+   *
+   * @param name
+   * @param x
+   * @param y
+   * @param z
+   * @param w
+   */
+  public void set(String name, boolean x, boolean y, boolean z, boolean w) {
     setUniformImpl(name, UniformValue.INT4,
-                   new int[] { (x)?1:0, (y)?1:0, (z)?1:0, (w)?1:0 });
+      new int[]{(x) ? 1 : 0, (y) ? 1 : 0, (z) ? 1 : 0, (w) ? 1 : 0});
   }
 
-    /**
-     *
-     * @param name
-     * @param vec
-     */
-    public void set(String name, int[] vec) {
+  /**
+   *
+   * @param name
+   * @param vec
+   */
+  public void set(String name, int[] vec) {
     set(name, vec, 1);
   }
 
-
   /**
-     * @param name
+   * @param name
    * @param ncoords number of coordinates per element, max 4
-     * @param vec
+   * @param vec
    */
   public void set(String name, int[] vec, int ncoords) {
     if (ncoords == 1) {
@@ -873,29 +867,29 @@ public class PShader implements PConstants {
     } else if (ncoords == 4) {
       setUniformImpl(name, UniformValue.INT4VEC, vec);
     } else if (4 < ncoords) {
-      PGraphics.showWarning("Only up to 4 coordinates per element are " +
-                            "supported.");
+      PGraphics.showWarning("Only up to 4 coordinates per element are "
+        + "supported.");
     } else {
       PGraphics.showWarning("Wrong number of coordinates: it is negative!");
     }
   }
 
-    /**
-     *
-     * @param name
-     * @param vec
-     */
-    public void set(String name, float[] vec) {
+  /**
+   *
+   * @param name
+   * @param vec
+   */
+  public void set(String name, float[] vec) {
     set(name, vec, 1);
   }
 
-    /**
-     *
-     * @param name
-     * @param vec
-     * @param ncoords
-     */
-    public void set(String name, float[] vec, int ncoords) {
+  /**
+   *
+   * @param name
+   * @param vec
+   * @param ncoords
+   */
+  public void set(String name, float[] vec, int ncoords) {
     if (ncoords == 1) {
       setUniformImpl(name, UniformValue.FLOAT1VEC, vec);
     } else if (ncoords == 2) {
@@ -905,108 +899,106 @@ public class PShader implements PConstants {
     } else if (ncoords == 4) {
       setUniformImpl(name, UniformValue.FLOAT4VEC, vec);
     } else if (4 < ncoords) {
-      PGraphics.showWarning("Only up to 4 coordinates per element are " +
-                            "supported.");
+      PGraphics.showWarning("Only up to 4 coordinates per element are "
+        + "supported.");
     } else {
       PGraphics.showWarning("Wrong number of coordinates: it is negative!");
     }
   }
 
-    /**
-     *
-     * @param name
-     * @param vec
-     */
-    public void set(String name, boolean[] vec) {
+  /**
+   *
+   * @param name
+   * @param vec
+   */
+  public void set(String name, boolean[] vec) {
     set(name, vec, 1);
   }
 
-    /**
-     *
-     * @param name
-     * @param boolvec
-     * @param ncoords
-     */
-    public void set(String name, boolean[] boolvec, int ncoords) {
+  /**
+   *
+   * @param name
+   * @param boolvec
+   * @param ncoords
+   */
+  public void set(String name, boolean[] boolvec, int ncoords) {
     int[] vec = new int[boolvec.length];
     for (int i = 0; i < boolvec.length; i++) {
-      vec[i] = (boolvec[i])?1:0;
+      vec[i] = (boolvec[i]) ? 1 : 0;
     }
     set(name, vec, ncoords);
   }
 
-
   /**
-     * @param name
+   * @param name
    * @param mat matrix of values
    */
   public void set(String name, PMatrix2D mat) {
-    float[] matv = { mat.m00, mat.m01,
-                     mat.m10, mat.m11 };
+    float[] matv = {mat.m00, mat.m01,
+      mat.m10, mat.m11};
     setUniformImpl(name, UniformValue.MAT2, matv);
   }
 
-    /**
-     *
-     * @param name
-     * @param mat
-     */
-    public void set(String name, PMatrix3D mat) {
+  /**
+   *
+   * @param name
+   * @param mat
+   */
+  public void set(String name, PMatrix3D mat) {
     set(name, mat, false);
   }
 
   /**
-     * @param name
+   * @param name
    * @param use3x3 enforces the matrix is 3 x 3
-     * @param mat
+   * @param mat
    */
   public void set(String name, PMatrix3D mat, boolean use3x3) {
     if (use3x3) {
-      float[] matv = { mat.m00, mat.m01, mat.m02,
-                       mat.m10, mat.m11, mat.m12,
-                       mat.m20, mat.m21, mat.m22 };
+      float[] matv = {mat.m00, mat.m01, mat.m02,
+        mat.m10, mat.m11, mat.m12,
+        mat.m20, mat.m21, mat.m22};
       setUniformImpl(name, UniformValue.MAT3, matv);
     } else {
-      float[] matv = { mat.m00, mat.m01, mat.m02, mat.m03,
-                       mat.m10, mat.m11, mat.m12, mat.m13,
-                       mat.m20, mat.m21, mat.m22, mat.m23,
-                       mat.m30, mat.m31, mat.m32, mat.m33 };
+      float[] matv = {mat.m00, mat.m01, mat.m02, mat.m03,
+        mat.m10, mat.m11, mat.m12, mat.m13,
+        mat.m20, mat.m21, mat.m22, mat.m23,
+        mat.m30, mat.m31, mat.m32, mat.m33};
       setUniformImpl(name, UniformValue.MAT4, matv);
     }
   }
 
   /**
-     * @param name
-   * @param tex sets the sampler uniform variable to read from this image texture
+   * @param name
+   * @param tex sets the sampler uniform variable to read from this image
+   * texture
    */
   public void set(String name, PImage tex) {
     setUniformImpl(name, UniformValue.SAMPLER2D, tex);
   }
 
-
   /**
    * Extra initialization method that can be used by subclasses, called after
-   * compiling and attaching the vertex and fragment shaders, and before
-   * linking the shader program.
+   * compiling and attaching the vertex and fragment shaders, and before linking
+   * the shader program.
    *
    */
   protected void setup() {
   }
 
-    /**
-     *
-     * @param idxId
-     * @param count
-     * @param offset
-     */
-    protected void draw(int idxId, int count, int offset) {
+  /**
+   *
+   * @param idxId
+   * @param count
+   * @param offset
+   */
+  protected void draw(int idxId, int count, int offset) {
     pgl.bindBuffer(PGL.ELEMENT_ARRAY_BUFFER, idxId);
     pgl.drawElements(PGL.TRIANGLES, count, PGL.INDEX_TYPE,
-                     offset * PGL.SIZEOF_INDEX);
+      offset * PGL.SIZEOF_INDEX);
     pgl.bindBuffer(PGL.ELEMENT_ARRAY_BUFFER, 0);
   }
 
-
   /**
    * Returns the ID location of the attribute parameter given its name.
    *
@@ -1018,7 +1010,6 @@ public class PShader implements PConstants {
     return pgl.getAttribLocation(glProgram, name);
   }
 
-
   /**
    * Returns the ID location of the uniform parameter given its name.
    *
@@ -1030,194 +1021,214 @@ public class PShader implements PConstants {
     return pgl.getUniformLocation(glProgram, name);
   }
 
-    /**
-     *
-     * @param loc
-     * @param vboId
-     * @param size
-     * @param type
-     * @param normalized
-     * @param stride
-     * @param offset
-     */
-    protected void setAttributeVBO(int loc, int vboId, int size, int type,
-                                 boolean normalized, int stride, int offset) {
+  /**
+   *
+   * @param loc
+   * @param vboId
+   * @param size
+   * @param type
+   * @param normalized
+   * @param stride
+   * @param offset
+   */
+  protected void setAttributeVBO(int loc, int vboId, int size, int type,
+    boolean normalized, int stride, int offset) {
     if (-1 < loc) {
       pgl.bindBuffer(PGL.ARRAY_BUFFER, vboId);
       pgl.vertexAttribPointer(loc, size, type, normalized, stride, offset);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param x
-     */
-    protected void setUniformValue(int loc, int x) {
+  /**
+   *
+   * @param loc
+   * @param x
+   */
+  protected void setUniformValue(int loc, int x) {
     if (-1 < loc) {
       pgl.uniform1i(loc, x);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param x
-     * @param y
-     */
-    protected void setUniformValue(int loc, int x, int y) {
+  /**
+   *
+   * @param loc
+   * @param x
+   * @param y
+   */
+  protected void setUniformValue(int loc, int x, int y) {
     if (-1 < loc) {
       pgl.uniform2i(loc, x, y);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param x
-     * @param y
-     * @param z
-     */
-    protected void setUniformValue(int loc, int x, int y, int z) {
+  /**
+   *
+   * @param loc
+   * @param x
+   * @param y
+   * @param z
+   */
+  protected void setUniformValue(int loc, int x, int y, int z) {
     if (-1 < loc) {
       pgl.uniform3i(loc, x, y, z);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param x
-     * @param y
-     * @param z
-     * @param w
-     */
-    protected void setUniformValue(int loc, int x, int y, int z, int w) {
+  /**
+   *
+   * @param loc
+   * @param x
+   * @param y
+   * @param z
+   * @param w
+   */
+  protected void setUniformValue(int loc, int x, int y, int z, int w) {
     if (-1 < loc) {
       pgl.uniform4i(loc, x, y, z, w);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param x
-     */
-    protected void setUniformValue(int loc, float x) {
+  /**
+   *
+   * @param loc
+   * @param x
+   */
+  protected void setUniformValue(int loc, float x) {
     if (-1 < loc) {
       pgl.uniform1f(loc, x);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param x
-     * @param y
-     */
-    protected void setUniformValue(int loc, float x, float y) {
+  /**
+   *
+   * @param loc
+   * @param x
+   * @param y
+   */
+  protected void setUniformValue(int loc, float x, float y) {
     if (-1 < loc) {
       pgl.uniform2f(loc, x, y);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param x
-     * @param y
-     * @param z
-     */
-    protected void setUniformValue(int loc, float x, float y, float z) {
+  /**
+   *
+   * @param loc
+   * @param x
+   * @param y
+   * @param z
+   */
+  protected void setUniformValue(int loc, float x, float y, float z) {
     if (-1 < loc) {
       pgl.uniform3f(loc, x, y, z);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param x
-     * @param y
-     * @param z
-     * @param w
-     */
-    protected void setUniformValue(int loc, float x, float y, float z, float w) {
+  /**
+   *
+   * @param loc
+   * @param x
+   * @param y
+   * @param z
+   * @param w
+   */
+  protected void setUniformValue(int loc, float x, float y, float z, float w) {
     if (-1 < loc) {
       pgl.uniform4f(loc, x, y, z, w);
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param vec
-     * @param ncoords
-     * @param length
-     */
-    protected void setUniformVector(int loc, int[] vec, int ncoords,
-                                  int length) {
+  /**
+   *
+   * @param loc
+   * @param vec
+   * @param ncoords
+   * @param length
+   */
+  protected void setUniformVector(int loc, int[] vec, int ncoords,
+    int length) {
     if (-1 < loc) {
       updateIntBuffer(vec);
-      if (ncoords == 1) {
-        pgl.uniform1iv(loc, length, intBuffer);
-      } else if (ncoords == 2) {
-        pgl.uniform2iv(loc, length, intBuffer);
-      } else if (ncoords == 3) {
-        pgl.uniform3iv(loc, length, intBuffer);
-      } else if (ncoords == 4) {
-        pgl.uniform3iv(loc, length, intBuffer);
+      switch (ncoords) {
+        case 1:
+          pgl.uniform1iv(loc, length, intBuffer);
+          break;
+        case 2:
+          pgl.uniform2iv(loc, length, intBuffer);
+          break;
+        case 3:
+          pgl.uniform3iv(loc, length, intBuffer);
+          break;
+        case 4:
+          pgl.uniform3iv(loc, length, intBuffer);
+          break;
+        default:
+          break;
       }
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param vec
-     * @param ncoords
-     * @param length
-     */
-    protected void setUniformVector(int loc, float[] vec, int ncoords,
-                                  int length) {
+  /**
+   *
+   * @param loc
+   * @param vec
+   * @param ncoords
+   * @param length
+   */
+  protected void setUniformVector(int loc, float[] vec, int ncoords,
+    int length) {
     if (-1 < loc) {
       updateFloatBuffer(vec);
-      if (ncoords == 1) {
-        pgl.uniform1fv(loc, length, floatBuffer);
-      } else if (ncoords == 2) {
-        pgl.uniform2fv(loc, length, floatBuffer);
-      } else if (ncoords == 3) {
-        pgl.uniform3fv(loc, length, floatBuffer);
-      } else if (ncoords == 4) {
-        pgl.uniform4fv(loc, length, floatBuffer);
+      switch (ncoords) {
+        case 1:
+          pgl.uniform1fv(loc, length, floatBuffer);
+          break;
+        case 2:
+          pgl.uniform2fv(loc, length, floatBuffer);
+          break;
+        case 3:
+          pgl.uniform3fv(loc, length, floatBuffer);
+          break;
+        case 4:
+          pgl.uniform4fv(loc, length, floatBuffer);
+          break;
+        default:
+          break;
       }
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param mat
-     */
-    protected void setUniformMatrix(int loc, float[] mat) {
+  /**
+   *
+   * @param loc
+   * @param mat
+   */
+  protected void setUniformMatrix(int loc, float[] mat) {
     if (-1 < loc) {
       updateFloatBuffer(mat);
-      if (mat.length == 4) {
-        pgl.uniformMatrix2fv(loc, 1, false, floatBuffer);
-      } else if (mat.length == 9) {
-        pgl.uniformMatrix3fv(loc, 1, false, floatBuffer);
-      } else if (mat.length == 16) {
-        pgl.uniformMatrix4fv(loc, 1, false, floatBuffer);
+      switch (mat.length) {
+        case 4:
+          pgl.uniformMatrix2fv(loc, 1, false, floatBuffer);
+          break;
+        case 9:
+          pgl.uniformMatrix3fv(loc, 1, false, floatBuffer);
+          break;
+        case 16:
+          pgl.uniformMatrix4fv(loc, 1, false, floatBuffer);
+          break;
+        default:
+          break;
       }
     }
   }
 
-    /**
-     *
-     * @param loc
-     * @param tex
-     */
-    protected void setUniformTex(int loc, Texture tex) {
+  /**
+   *
+   * @param loc
+   * @param tex
+   */
+  protected void setUniformTex(int loc, Texture tex) {
     if (texUnits != null) {
       Integer unit = texUnits.get(loc);
       if (unit != null) {
@@ -1229,146 +1240,190 @@ public class PShader implements PConstants {
     }
   }
 
-    /**
-     *
-     * @param name
-     * @param type
-     * @param value
-     */
-    protected void setUniformImpl(String name, int type, Object value) {
+  /**
+   *
+   * @param name
+   * @param type
+   * @param value
+   */
+  protected void setUniformImpl(String name, int type, Object value) {
     if (uniformValues == null) {
-      uniformValues = new HashMap<String, UniformValue>();
+      uniformValues = new HashMap<>();
     }
     uniformValues.put(name, new UniformValue(type, value));
   }
 
-    /**
-     *
-     */
-    protected void consumeUniforms() {
+  /**
+   *
+   */
+  protected void consumeUniforms() {
     if (uniformValues != null && 0 < uniformValues.size()) {
       int unit = 0;
-      for (String name: uniformValues.keySet()) {
+      for (String name : uniformValues.keySet()) {
         int loc = getUniformLoc(name);
         if (loc == -1) {
-          PGraphics.showWarning("The shader doesn't have a uniform called \"" +
-                                name + "\" OR the uniform was removed during " +
-                                "compilation because it was unused.");
+          PGraphics.showWarning("The shader doesn't have a uniform called \""
+            + name + "\" OR the uniform was removed during "
+            + "compilation because it was unused.");
           continue;
         }
         UniformValue val = uniformValues.get(name);
-        if (val.type == UniformValue.INT1) {
-          int[] v = ((int[])val.value);
-          pgl.uniform1i(loc, v[0]);
-        } else if (val.type == UniformValue.INT2) {
-          int[] v = ((int[])val.value);
-          pgl.uniform2i(loc, v[0], v[1]);
-        } else if (val.type == UniformValue.INT3) {
-          int[] v = ((int[])val.value);
-          pgl.uniform3i(loc, v[0], v[1], v[2]);
-        } else if (val.type == UniformValue.INT4) {
-          int[] v = ((int[])val.value);
-          pgl.uniform4i(loc, v[0], v[1], v[2], v[3]);
-        } else if (val.type == UniformValue.FLOAT1) {
-          float[] v = ((float[])val.value);
-          pgl.uniform1f(loc, v[0]);
-        } else if (val.type == UniformValue.FLOAT2) {
-          float[] v = ((float[])val.value);
-          pgl.uniform2f(loc, v[0], v[1]);
-        } else if (val.type == UniformValue.FLOAT3) {
-          float[] v = ((float[])val.value);
-          pgl.uniform3f(loc, v[0], v[1], v[2]);
-        } else if (val.type == UniformValue.FLOAT4) {
-          float[] v = ((float[])val.value);
-          pgl.uniform4f(loc, v[0], v[1], v[2], v[3]);
-        } else if (val.type == UniformValue.INT1VEC) {
-          int[] v = ((int[])val.value);
-          updateIntBuffer(v);
-          pgl.uniform1iv(loc, v.length, intBuffer);
-        } else if (val.type == UniformValue.INT2VEC) {
-          int[] v = ((int[])val.value);
-          updateIntBuffer(v);
-          pgl.uniform2iv(loc, v.length / 2, intBuffer);
-        } else if (val.type == UniformValue.INT3VEC) {
-          int[] v = ((int[])val.value);
-          updateIntBuffer(v);
-          pgl.uniform3iv(loc, v.length / 3, intBuffer);
-        } else if (val.type == UniformValue.INT4VEC) {
-          int[] v = ((int[])val.value);
-          updateIntBuffer(v);
-          pgl.uniform4iv(loc, v.length / 4, intBuffer);
-        } else if (val.type == UniformValue.FLOAT1VEC) {
-          float[] v = ((float[])val.value);
-          updateFloatBuffer(v);
-          pgl.uniform1fv(loc, v.length, floatBuffer);
-        } else if (val.type == UniformValue.FLOAT2VEC) {
-          float[] v = ((float[])val.value);
-          updateFloatBuffer(v);
-          pgl.uniform2fv(loc, v.length / 2, floatBuffer);
-        } else if (val.type == UniformValue.FLOAT3VEC) {
-          float[] v = ((float[])val.value);
-          updateFloatBuffer(v);
-          pgl.uniform3fv(loc, v.length / 3, floatBuffer);
-        } else if (val.type == UniformValue.FLOAT4VEC) {
-          float[] v = ((float[])val.value);
-          updateFloatBuffer(v);
-          pgl.uniform4fv(loc, v.length / 4, floatBuffer);
-        } else if (val.type == UniformValue.MAT2) {
-          float[] v = ((float[])val.value);
-          updateFloatBuffer(v);
-          pgl.uniformMatrix2fv(loc, 1, false, floatBuffer);
-        } else if (val.type == UniformValue.MAT3) {
-          float[] v = ((float[])val.value);
-          updateFloatBuffer(v);
-          pgl.uniformMatrix3fv(loc, 1, false, floatBuffer);
-        } else if (val.type == UniformValue.MAT4) {
-          float[] v = ((float[])val.value);
-          updateFloatBuffer(v);
-          pgl.uniformMatrix4fv(loc, 1, false, floatBuffer);
-        } else if (val.type == UniformValue.SAMPLER2D) {
-          PImage img = (PImage)val.value;
-          Texture tex = currentPG.getTexture(img);
-
-          if (textures == null) textures = new HashMap<Integer, Texture>();
-          textures.put(loc, tex);
-
-          if (texUnits == null) texUnits = new HashMap<Integer, Integer>();
-          if (texUnits.containsKey(loc)) {
-            unit = texUnits.get(loc);
-            pgl.uniform1i(loc, unit);
-          } else {
-            texUnits.put(loc, unit);
-            pgl.uniform1i(loc, unit);
+        switch (val.type) {
+          case UniformValue.INT1: {
+            int[] v = ((int[]) val.value);
+            pgl.uniform1i(loc, v[0]);
+            break;
+          }
+          case UniformValue.INT2: {
+            int[] v = ((int[]) val.value);
+            pgl.uniform2i(loc, v[0], v[1]);
+            break;
           }
-          unit++;
+          case UniformValue.INT3: {
+            int[] v = ((int[]) val.value);
+            pgl.uniform3i(loc, v[0], v[1], v[2]);
+            break;
+          }
+          case UniformValue.INT4: {
+            int[] v = ((int[]) val.value);
+            pgl.uniform4i(loc, v[0], v[1], v[2], v[3]);
+            break;
+          }
+          case UniformValue.FLOAT1: {
+            float[] v = ((float[]) val.value);
+            pgl.uniform1f(loc, v[0]);
+            break;
+          }
+          case UniformValue.FLOAT2: {
+            float[] v = ((float[]) val.value);
+            pgl.uniform2f(loc, v[0], v[1]);
+            break;
+          }
+          case UniformValue.FLOAT3: {
+            float[] v = ((float[]) val.value);
+            pgl.uniform3f(loc, v[0], v[1], v[2]);
+            break;
+          }
+          case UniformValue.FLOAT4: {
+            float[] v = ((float[]) val.value);
+            pgl.uniform4f(loc, v[0], v[1], v[2], v[3]);
+            break;
+          }
+          case UniformValue.INT1VEC: {
+            int[] v = ((int[]) val.value);
+            updateIntBuffer(v);
+            pgl.uniform1iv(loc, v.length, intBuffer);
+            break;
+          }
+          case UniformValue.INT2VEC: {
+            int[] v = ((int[]) val.value);
+            updateIntBuffer(v);
+            pgl.uniform2iv(loc, v.length / 2, intBuffer);
+            break;
+          }
+          case UniformValue.INT3VEC: {
+            int[] v = ((int[]) val.value);
+            updateIntBuffer(v);
+            pgl.uniform3iv(loc, v.length / 3, intBuffer);
+            break;
+          }
+          case UniformValue.INT4VEC: {
+            int[] v = ((int[]) val.value);
+            updateIntBuffer(v);
+            pgl.uniform4iv(loc, v.length / 4, intBuffer);
+            break;
+          }
+          case UniformValue.FLOAT1VEC: {
+            float[] v = ((float[]) val.value);
+            updateFloatBuffer(v);
+            pgl.uniform1fv(loc, v.length, floatBuffer);
+            break;
+          }
+          case UniformValue.FLOAT2VEC: {
+            float[] v = ((float[]) val.value);
+            updateFloatBuffer(v);
+            pgl.uniform2fv(loc, v.length / 2, floatBuffer);
+            break;
+          }
+          case UniformValue.FLOAT3VEC: {
+            float[] v = ((float[]) val.value);
+            updateFloatBuffer(v);
+            pgl.uniform3fv(loc, v.length / 3, floatBuffer);
+            break;
+          }
+          case UniformValue.FLOAT4VEC: {
+            float[] v = ((float[]) val.value);
+            updateFloatBuffer(v);
+            pgl.uniform4fv(loc, v.length / 4, floatBuffer);
+            break;
+          }
+          case UniformValue.MAT2: {
+            float[] v = ((float[]) val.value);
+            updateFloatBuffer(v);
+            pgl.uniformMatrix2fv(loc, 1, false, floatBuffer);
+            break;
+          }
+          case UniformValue.MAT3: {
+            float[] v = ((float[]) val.value);
+            updateFloatBuffer(v);
+            pgl.uniformMatrix3fv(loc, 1, false, floatBuffer);
+            break;
+          }
+          case UniformValue.MAT4: {
+            float[] v = ((float[]) val.value);
+            updateFloatBuffer(v);
+            pgl.uniformMatrix4fv(loc, 1, false, floatBuffer);
+            break;
+          }
+          case UniformValue.SAMPLER2D:
+            PImage img = (PImage) val.value;
+            Texture tex = currentPG.getTexture(img);
+            if (textures == null) {
+              textures = new HashMap<>();
+            }
+            textures.put(loc, tex);
+            if (texUnits == null) {
+              texUnits = new HashMap<>();
+            }
+            if (texUnits.containsKey(loc)) {
+              unit = texUnits.get(loc);
+              pgl.uniform1i(loc, unit);
+            } else {
+              texUnits.put(loc, unit);
+              pgl.uniform1i(loc, unit);
+            }
+            unit++;
+            break;
+          default:
+            break;
         }
       }
       uniformValues.clear();
     }
   }
 
-    /**
-     *
-     * @param vec
-     */
-    protected void updateIntBuffer(int[] vec) {
+  /**
+   *
+   * @param vec
+   */
+  protected void updateIntBuffer(int[] vec) {
     intBuffer = PGL.updateIntBuffer(intBuffer, vec, false);
   }
 
-    /**
-     *
-     * @param vec
-     */
-    protected void updateFloatBuffer(float[] vec) {
+  /**
+   *
+   * @param vec
+   */
+  protected void updateFloatBuffer(float[] vec) {
     floatBuffer = PGL.updateFloatBuffer(floatBuffer, vec, false);
   }
 
-    /**
-     *
-     */
-    protected void bindTextures() {
+  /**
+   *
+   */
+  protected void bindTextures() {
     if (textures != null && texUnits != null) {
-      for (int loc: textures.keySet()) {
+      textures.keySet().forEach((loc) -> {
         Texture tex = textures.get(loc);
         Integer unit = texUnits.get(loc);
         if (unit != null) {
@@ -1377,16 +1432,16 @@ public class PShader implements PConstants {
         } else {
           throw new RuntimeException("Cannot find unit for texture " + tex);
         }
-      }
+      });
     }
   }
 
-    /**
-     *
-     */
-    protected void unbindTextures() {
+  /**
+   *
+   */
+  protected void unbindTextures() {
     if (textures != null && texUnits != null) {
-      for (int loc: textures.keySet()) {
+      textures.keySet().forEach((loc) -> {
         Texture tex = textures.get(loc);
         Integer unit = texUnits.get(loc);
         if (unit != null) {
@@ -1395,15 +1450,15 @@ public class PShader implements PConstants {
         } else {
           throw new RuntimeException("Cannot find unit for texture " + tex);
         }
-      }
+      });
       pgl.activeTexture(PGL.TEXTURE0);
     }
   }
 
-    /**
-     *
-     */
-    public void init() {
+  /**
+   *
+   */
+  public void init() {
     if (glProgram == 0 || contextIsOutdated()) {
       create();
       if (compile()) {
@@ -1419,19 +1474,19 @@ public class PShader implements PConstants {
     }
   }
 
-    /**
-     *
-     */
-    protected void create() {
+  /**
+   *
+   */
+  protected void create() {
     context = pgl.getCurrentContext();
     glres = new GLResourceShader(this);
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean compile() {
+  /**
+   *
+   * @return
+   */
+  protected boolean compile() {
     boolean vertRes = true;
     if (hasVertexShader()) {
       vertRes = compileVertexShader();
@@ -1449,31 +1504,31 @@ public class PShader implements PConstants {
     return vertRes && fragRes;
   }
 
-    /**
-     *
-     */
-    protected void validate() {
+  /**
+   *
+   */
+  protected void validate() {
     pgl.getProgramiv(glProgram, PGL.LINK_STATUS, intBuffer);
-    boolean linked = intBuffer.get(0) == 0 ? false : true;
+    boolean linked = intBuffer.get(0) != 0;
     if (!linked) {
-      PGraphics.showException("Cannot link shader program:\n" +
-                              pgl.getProgramInfoLog(glProgram));
+      PGraphics.showException("Cannot link shader program:\n"
+        + pgl.getProgramInfoLog(glProgram));
     }
 
     pgl.validateProgram(glProgram);
     pgl.getProgramiv(glProgram, PGL.VALIDATE_STATUS, intBuffer);
-    boolean validated = intBuffer.get(0) == 0 ? false : true;
+    boolean validated = intBuffer.get(0) != 0;
     if (!validated) {
-      PGraphics.showException("Cannot validate shader program:\n" +
-                              pgl.getProgramInfoLog(glProgram));
+      PGraphics.showException("Cannot validate shader program:\n"
+        + pgl.getProgramInfoLog(glProgram));
     }
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean contextIsOutdated() {
+  /**
+   *
+   * @return
+   */
+  protected boolean contextIsOutdated() {
     boolean outdated = !pgl.contextIsCurrent(context);
     if (outdated) {
       dispose();
@@ -1481,66 +1536,62 @@ public class PShader implements PConstants {
     return outdated;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean hasVertexShader() {
+  /**
+   *
+   * @return
+   */
+  protected boolean hasVertexShader() {
     return vertexShaderSource != null && 0 < vertexShaderSource.length;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean hasFragmentShader() {
+  /**
+   *
+   * @return
+   */
+  protected boolean hasFragmentShader() {
     return fragmentShaderSource != null && 0 < fragmentShaderSource.length;
   }
 
-
   /**
-   * @param shaderSource a string containing the shader's code
-     * @return 
+   * @return
    */
   protected boolean compileVertexShader() {
     pgl.shaderSource(glVertex, PApplet.join(vertexShaderSource, "\n"));
     pgl.compileShader(glVertex);
 
     pgl.getShaderiv(glVertex, PGL.COMPILE_STATUS, intBuffer);
-    boolean compiled = intBuffer.get(0) == 0 ? false : true;
+    boolean compiled = intBuffer.get(0) != 0;
     if (!compiled) {
-      PGraphics.showException("Cannot compile vertex shader:\n" +
-                              pgl.getShaderInfoLog(glVertex));
+      PGraphics.showException("Cannot compile vertex shader:\n"
+        + pgl.getShaderInfoLog(glVertex));
       return false;
     } else {
       return true;
     }
   }
 
-
   /**
-   * @param shaderSource a string containing the shader's code
-     * @return 
+   * @return
    */
   protected boolean compileFragmentShader() {
     pgl.shaderSource(glFragment, PApplet.join(fragmentShaderSource, "\n"));
     pgl.compileShader(glFragment);
 
     pgl.getShaderiv(glFragment, PGL.COMPILE_STATUS, intBuffer);
-    boolean compiled = intBuffer.get(0) == 0 ? false : true;
+    boolean compiled = intBuffer.get(0) != 0;
     if (!compiled) {
-      PGraphics.showException("Cannot compile fragment shader:\n" +
-                              pgl.getShaderInfoLog(glFragment));
+      PGraphics.showException("Cannot compile fragment shader:\n"
+        + pgl.getShaderInfoLog(glFragment));
       return false;
     } else {
       return true;
     }
   }
 
-    /**
-     *
-     */
-    protected void dispose() {
+  /**
+   *
+   */
+  protected void dispose() {
     if (glres != null) {
       glres.dispose();
       glVertex = 0;
@@ -1550,118 +1601,123 @@ public class PShader implements PConstants {
     }
   }
 
-    /**
-     *
-     * @param source
-     * @param defaultType
-     * @return
-     */
-    static protected int getShaderType(String[] source, int defaultType) {
-    for (int i = 0; i < source.length; i++) {
-      String line = source[i].trim();
-
-      if (PApplet.match(line, colorShaderDefRegexp) != null)
+  /**
+   *
+   * @param source
+   * @param defaultType
+   * @return
+   */
+  static protected int getShaderType(String[] source, int defaultType) {
+    for (String source1 : source) {
+      String line = source1.trim();
+      if (PApplet.match(line, colorShaderDefRegexp) != null) {
         return PShader.COLOR;
-      else if (PApplet.match(line, lightShaderDefRegexp) != null)
+      } else if (PApplet.match(line, lightShaderDefRegexp) != null) {
         return PShader.LIGHT;
-      else if (PApplet.match(line, texShaderDefRegexp) != null)
+      } else if (PApplet.match(line, texShaderDefRegexp) != null) {
         return PShader.TEXTURE;
-      else if (PApplet.match(line, texlightShaderDefRegexp) != null)
+      } else if (PApplet.match(line, texlightShaderDefRegexp) != null) {
         return PShader.TEXLIGHT;
-      else if (PApplet.match(line, polyShaderDefRegexp) != null)
+      } else if (PApplet.match(line, polyShaderDefRegexp) != null) {
         return PShader.POLY;
-      else if (PApplet.match(line, triShaderAttrRegexp) != null)
+      } else if (PApplet.match(line, triShaderAttrRegexp) != null) {
         return PShader.POLY;
-      else if (PApplet.match(line, quadShaderAttrRegexp) != null)
+      } else if (PApplet.match(line, quadShaderAttrRegexp) != null) {
         return PShader.POLY;
-      else if (PApplet.match(line, pointShaderDefRegexp) != null)
+      } else if (PApplet.match(line, pointShaderDefRegexp) != null) {
         return PShader.POINT;
-      else if (PApplet.match(line, lineShaderDefRegexp) != null)
+      } else if (PApplet.match(line, lineShaderDefRegexp) != null) {
         return PShader.LINE;
-      else if (PApplet.match(line, pointShaderAttrRegexp) != null)
+      } else if (PApplet.match(line, pointShaderAttrRegexp) != null) {
         return PShader.POINT;
-      else if (PApplet.match(line, pointShaderInRegexp) != null)
+      } else if (PApplet.match(line, pointShaderInRegexp) != null) {
         return PShader.POINT;
-      else if (PApplet.match(line, lineShaderAttrRegexp) != null)
+      } else if (PApplet.match(line, lineShaderAttrRegexp) != null) {
         return PShader.LINE;
-      else if (PApplet.match(line, lineShaderInRegexp) != null)
+      } else if (PApplet.match(line, lineShaderInRegexp) != null) {
         return PShader.LINE;
+      }
     }
     return defaultType;
   }
 
-
   // ***************************************************************************
   //
   // Processing specific
-
-    /**
-     *
-     * @return
-     */
-
-
+  /**
+   *
+   * @return
+   */
   protected int getType() {
     return type;
   }
 
-    /**
-     *
-     * @param type
-     */
-    protected void setType(int type) {
+  /**
+   *
+   * @param type
+   */
+  protected void setType(int type) {
     this.type = type;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean hasType() {
+  /**
+   *
+   * @return
+   */
+  protected boolean hasType() {
     return POINT <= type && type <= TEXLIGHT;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean isPointShader() {
+  /**
+   *
+   * @return
+   */
+  protected boolean isPointShader() {
     return type == POINT;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean isLineShader() {
+  /**
+   *
+   * @return
+   */
+  protected boolean isLineShader() {
     return type == LINE;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean isPolyShader() {
+  /**
+   *
+   * @return
+   */
+  protected boolean isPolyShader() {
     return POLY <= type && type <= TEXLIGHT;
   }
 
-    /**
-     *
-     * @param type
-     * @return
-     */
-    protected boolean checkPolyType(int type) {
-    if (getType() == PShader.POLY) return true;
+  /**
+   *
+   * @param type
+   * @return
+   */
+  protected boolean checkPolyType(int type) {
+    if (getType() == PShader.POLY) {
+      return true;
+    }
 
     if (getType() != type) {
-      if (type == TEXLIGHT) {
-        PGraphics.showWarning(PGraphicsOpenGL.NO_TEXLIGHT_SHADER_ERROR);
-      } else if (type == LIGHT) {
-        PGraphics.showWarning(PGraphicsOpenGL.NO_LIGHT_SHADER_ERROR);
-      } else if (type == TEXTURE) {
-        PGraphics.showWarning(PGraphicsOpenGL.NO_TEXTURE_SHADER_ERROR);
-      } else if (type == COLOR) {
-        PGraphics.showWarning(PGraphicsOpenGL.NO_COLOR_SHADER_ERROR);
+      switch (type) {
+        case TEXLIGHT:
+          PGraphics.showWarning(PGraphicsOpenGL.NO_TEXLIGHT_SHADER_ERROR);
+          break;
+        case LIGHT:
+          PGraphics.showWarning(PGraphicsOpenGL.NO_LIGHT_SHADER_ERROR);
+          break;
+        case TEXTURE:
+          PGraphics.showWarning(PGraphicsOpenGL.NO_TEXTURE_SHADER_ERROR);
+          break;
+        case COLOR:
+          PGraphics.showWarning(PGraphicsOpenGL.NO_COLOR_SHADER_ERROR);
+          break;
+        default:
+          break;
       }
       return false;
     }
@@ -1669,30 +1725,34 @@ public class PShader implements PConstants {
     return true;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected int getLastTexUnit() {
+  /**
+   *
+   * @return
+   */
+  protected int getLastTexUnit() {
     return texUnits == null ? -1 : texUnits.size() - 1;
   }
 
-    /**
-     *
-     * @param pg
-     */
-    protected void setRenderer(PGraphicsOpenGL pg) {
+  /**
+   *
+   * @param pg
+   */
+  protected void setRenderer(PGraphicsOpenGL pg) {
     this.currentPG = pg;
   }
 
-    /**
-     *
-     */
-    protected void loadAttributes() {
-    if (loadedAttributes) return;
+  /**
+   *
+   */
+  protected void loadAttributes() {
+    if (loadedAttributes) {
+      return;
+    }
 
     vertexLoc = getAttributeLoc("vertex");
-    if (vertexLoc == -1) vertexLoc = getAttributeLoc("position");
+    if (vertexLoc == -1) {
+      vertexLoc = getAttributeLoc("position");
+    }
 
     colorLoc = getAttributeLoc("color");
     texCoordLoc = getAttributeLoc("texCoord");
@@ -1713,22 +1773,27 @@ public class PShader implements PConstants {
     loadedAttributes = true;
   }
 
-    /**
-     *
-     */
-    protected void loadUniforms() {
-    if (loadedUniforms) return;
+  /**
+   *
+   */
+  protected void loadUniforms() {
+    if (loadedUniforms) {
+      return;
+    }
     transformMatLoc = getUniformLoc("transform");
-    if (transformMatLoc == -1)
+    if (transformMatLoc == -1) {
       transformMatLoc = getUniformLoc("transformMatrix");
+    }
 
     modelviewMatLoc = getUniformLoc("modelview");
-    if (modelviewMatLoc == -1)
+    if (modelviewMatLoc == -1) {
       modelviewMatLoc = getUniformLoc("modelviewMatrix");
+    }
 
     projectionMatLoc = getUniformLoc("projection");
-    if (projectionMatLoc == -1)
+    if (projectionMatLoc == -1) {
       projectionMatLoc = getUniformLoc("projectionMatrix");
+    }
 
     viewportLoc = getUniformLoc("viewport");
     resolutionLoc = getUniformLoc("resolution");
@@ -1758,10 +1823,10 @@ public class PShader implements PConstants {
     loadedUniforms = true;
   }
 
-    /**
-     *
-     */
-    protected void setCommonUniforms() {
+  /**
+   *
+   */
+  protected void setCommonUniforms() {
     if (-1 < transformMatLoc) {
       currentPG.updateGLProjmodelview();
       setUniformMatrix(transformMatLoc, currentPG.glProjmodelview);
@@ -1801,10 +1866,10 @@ public class PShader implements PConstants {
     }
   }
 
-    /**
-     *
-     */
-    protected void bindTyped() {
+  /**
+   *
+   */
+  protected void bindTyped() {
     if (currentPG == null) {
       setRenderer(primaryPG.getCurrentPG());
       loadAttributes();
@@ -1812,20 +1877,36 @@ public class PShader implements PConstants {
     }
     setCommonUniforms();
 
-    if (-1 < vertexLoc) pgl.enableVertexAttribArray(vertexLoc);
-    if (-1 < colorLoc) pgl.enableVertexAttribArray(colorLoc);
-    if (-1 < texCoordLoc) pgl.enableVertexAttribArray(texCoordLoc);
-    if (-1 < normalLoc) pgl.enableVertexAttribArray(normalLoc);
+    if (-1 < vertexLoc) {
+      pgl.enableVertexAttribArray(vertexLoc);
+    }
+    if (-1 < colorLoc) {
+      pgl.enableVertexAttribArray(colorLoc);
+    }
+    if (-1 < texCoordLoc) {
+      pgl.enableVertexAttribArray(texCoordLoc);
+    }
+    if (-1 < normalLoc) {
+      pgl.enableVertexAttribArray(normalLoc);
+    }
 
     if (-1 < normalMatLoc) {
       currentPG.updateGLNormal();
       setUniformMatrix(normalMatLoc, currentPG.glNormal);
     }
 
-    if (-1 < ambientLoc) pgl.enableVertexAttribArray(ambientLoc);
-    if (-1 < specularLoc) pgl.enableVertexAttribArray(specularLoc);
-    if (-1 < emissiveLoc) pgl.enableVertexAttribArray(emissiveLoc);
-    if (-1 < shininessLoc) pgl.enableVertexAttribArray(shininessLoc);
+    if (-1 < ambientLoc) {
+      pgl.enableVertexAttribArray(ambientLoc);
+    }
+    if (-1 < specularLoc) {
+      pgl.enableVertexAttribArray(specularLoc);
+    }
+    if (-1 < emissiveLoc) {
+      pgl.enableVertexAttribArray(emissiveLoc);
+    }
+    if (-1 < shininessLoc) {
+      pgl.enableVertexAttribArray(shininessLoc);
+    }
 
     int count = currentPG.lightCount;
     setUniformValue(lightCountLoc, count);
@@ -1836,17 +1917,21 @@ public class PShader implements PConstants {
       setUniformVector(lightDiffuseLoc, currentPG.lightDiffuse, 3, count);
       setUniformVector(lightSpecularLoc, currentPG.lightSpecular, 3, count);
       setUniformVector(lightFalloffLoc, currentPG.lightFalloffCoefficients,
-                       3, count);
+        3, count);
       setUniformVector(lightSpotLoc, currentPG.lightSpotParameters, 2, count);
     }
 
-    if (-1 < directionLoc) pgl.enableVertexAttribArray(directionLoc);
+    if (-1 < directionLoc) {
+      pgl.enableVertexAttribArray(directionLoc);
+    }
 
-    if (-1 < offsetLoc) pgl.enableVertexAttribArray(offsetLoc);
+    if (-1 < offsetLoc) {
+      pgl.enableVertexAttribArray(offsetLoc);
+    }
 
     if (-1 < perspectiveLoc) {
-      if (currentPG.getHint(ENABLE_STROKE_PERSPECTIVE) &&
-          currentPG.nonOrthoProjection()) {
+      if (currentPG.getHint(ENABLE_STROKE_PERSPECTIVE)
+        && currentPG.nonOrthoProjection()) {
         setUniformValue(perspectiveLoc, 1);
       } else {
         setUniformValue(perspectiveLoc, 0);
@@ -1867,13 +1952,17 @@ public class PShader implements PConstants {
     }
   }
 
-    /**
-     *
-     */
-    protected void unbindTyped() {
-    if (-1 < offsetLoc) pgl.disableVertexAttribArray(offsetLoc);
+  /**
+   *
+   */
+  protected void unbindTyped() {
+    if (-1 < offsetLoc) {
+      pgl.disableVertexAttribArray(offsetLoc);
+    }
 
-    if (-1 < directionLoc) pgl.disableVertexAttribArray(directionLoc);
+    if (-1 < directionLoc) {
+      pgl.disableVertexAttribArray(directionLoc);
+    }
 
     if (-1 < textureLoc && texture != null) {
       pgl.activeTexture(PGL.TEXTURE0 + texUnit);
@@ -1882,15 +1971,31 @@ public class PShader implements PConstants {
       texture = null;
     }
 
-    if (-1 < ambientLoc) pgl.disableVertexAttribArray(ambientLoc);
-    if (-1 < specularLoc) pgl.disableVertexAttribArray(specularLoc);
-    if (-1 < emissiveLoc) pgl.disableVertexAttribArray(emissiveLoc);
-    if (-1 < shininessLoc) pgl.disableVertexAttribArray(shininessLoc);
+    if (-1 < ambientLoc) {
+      pgl.disableVertexAttribArray(ambientLoc);
+    }
+    if (-1 < specularLoc) {
+      pgl.disableVertexAttribArray(specularLoc);
+    }
+    if (-1 < emissiveLoc) {
+      pgl.disableVertexAttribArray(emissiveLoc);
+    }
+    if (-1 < shininessLoc) {
+      pgl.disableVertexAttribArray(shininessLoc);
+    }
 
-    if (-1 < vertexLoc) pgl.disableVertexAttribArray(vertexLoc);
-    if (-1 < colorLoc) pgl.disableVertexAttribArray(colorLoc);
-    if (-1 < texCoordLoc) pgl.disableVertexAttribArray(texCoordLoc);
-    if (-1 < normalLoc) pgl.disableVertexAttribArray(normalLoc);
+    if (-1 < vertexLoc) {
+      pgl.disableVertexAttribArray(vertexLoc);
+    }
+    if (-1 < colorLoc) {
+      pgl.disableVertexAttribArray(colorLoc);
+    }
+    if (-1 < texCoordLoc) {
+      pgl.disableVertexAttribArray(texCoordLoc);
+    }
+    if (-1 < normalLoc) {
+      pgl.disableVertexAttribArray(normalLoc);
+    }
 
     if (-1 < ppixelsLoc) {
       pgl.enableFBOLayer();
@@ -1902,38 +2007,38 @@ public class PShader implements PConstants {
     pgl.bindBuffer(PGL.ARRAY_BUFFER, 0);
   }
 
-    /**
-     *
-     * @param tex
-     */
-    protected void setTexture(Texture tex) {
+  /**
+   *
+   * @param tex
+   */
+  protected void setTexture(Texture tex) {
     texture = tex;
 
     float scaleu = 1;
     float scalev = 1;
-    float dispu  = 0;
-    float dispv  = 0;
+    float dispu = 0;
+    float dispv = 0;
 
     if (tex != null) {
       if (tex.invertedX()) {
         scaleu = -1;
-        dispu  = 1;
+        dispu = 1;
       }
 
       if (tex.invertedY()) {
         scalev = -1;
-        dispv  = 1;
+        dispv = 1;
       }
 
       scaleu *= tex.maxTexcoordU();
-      dispu  *= tex.maxTexcoordU();
+      dispu *= tex.maxTexcoordU();
       scalev *= tex.maxTexcoordV();
-      dispv  *= tex.maxTexcoordV();
+      dispv *= tex.maxTexcoordV();
 
       setUniformValue(texOffsetLoc, 1.0f / tex.width, 1.0f / tex.height);
 
       if (-1 < textureLoc) {
-        texUnit =  -1 < ppixelsUnit ? ppixelsUnit + 1 : getLastTexUnit() + 1;
+        texUnit = -1 < ppixelsUnit ? ppixelsUnit + 1 : getLastTexUnit() + 1;
         setUniformValue(textureLoc, texUnit);
         pgl.activeTexture(PGL.TEXTURE0 + texUnit);
         tex.bind();
@@ -1944,214 +2049,225 @@ public class PShader implements PConstants {
       if (tcmat == null) {
         tcmat = new float[16];
       }
-      tcmat[0] = scaleu; tcmat[4] = 0;      tcmat[ 8] = 0; tcmat[12] = dispu;
-      tcmat[1] = 0;      tcmat[5] = scalev; tcmat[ 9] = 0; tcmat[13] = dispv;
-      tcmat[2] = 0;      tcmat[6] = 0;      tcmat[10] = 0; tcmat[14] = 0;
-      tcmat[3] = 0;      tcmat[7] = 0;      tcmat[11] = 0; tcmat[15] = 0;
+      tcmat[0] = scaleu;
+      tcmat[4] = 0;
+      tcmat[8] = 0;
+      tcmat[12] = dispu;
+      tcmat[1] = 0;
+      tcmat[5] = scalev;
+      tcmat[9] = 0;
+      tcmat[13] = dispv;
+      tcmat[2] = 0;
+      tcmat[6] = 0;
+      tcmat[10] = 0;
+      tcmat[14] = 0;
+      tcmat[3] = 0;
+      tcmat[7] = 0;
+      tcmat[11] = 0;
+      tcmat[15] = 0;
       setUniformMatrix(texMatrixLoc, tcmat);
     }
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean supportsTexturing() {
+  /**
+   *
+   * @return
+   */
+  protected boolean supportsTexturing() {
     return -1 < textureLoc;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean supportLighting() {
+  /**
+   *
+   * @return
+   */
+  protected boolean supportLighting() {
     return -1 < lightCountLoc || -1 < lightPositionLoc || -1 < lightNormalLoc;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean accessTexCoords() {
+  /**
+   *
+   * @return
+   */
+  protected boolean accessTexCoords() {
     return -1 < texCoordLoc;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean accessNormals() {
+  /**
+   *
+   * @return
+   */
+  protected boolean accessNormals() {
     return -1 < normalLoc;
   }
 
-    /**
-     *
-     * @return
-     */
-    protected boolean accessLightAttribs() {
-    return -1 < ambientLoc || -1 < specularLoc || -1 < emissiveLoc ||
-           -1 < shininessLoc;
-  }
-
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setVertexAttribute(int vboId, int size, int type,
-                                    int stride, int offset) {
+  /**
+   *
+   * @return
+   */
+  protected boolean accessLightAttribs() {
+    return -1 < ambientLoc || -1 < specularLoc || -1 < emissiveLoc
+      || -1 < shininessLoc;
+  }
+
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setVertexAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(vertexLoc, vboId, size, type, false, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setColorAttribute(int vboId, int size, int type,
-                                   int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setColorAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(colorLoc, vboId, size, type, true, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setNormalAttribute(int vboId, int size, int type,
-                                    int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setNormalAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(normalLoc, vboId, size, type, false, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setTexcoordAttribute(int vboId, int size, int type,
-                                      int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setTexcoordAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(texCoordLoc, vboId, size, type, false, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setAmbientAttribute(int vboId, int size, int type,
-                                     int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setAmbientAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(ambientLoc, vboId, size, type, true, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setSpecularAttribute(int vboId, int size, int type,
-                                      int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setSpecularAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(specularLoc, vboId, size, type, true, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setEmissiveAttribute(int vboId, int size, int type,
-                                      int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setEmissiveAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(emissiveLoc, vboId, size, type, true, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setShininessAttribute(int vboId, int size, int type,
-                                       int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setShininessAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(shininessLoc, vboId, size, type, false, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setLineAttribute(int vboId, int size, int type,
-                                  int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setLineAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(directionLoc, vboId, size, type, false, stride, offset);
   }
 
-    /**
-     *
-     * @param vboId
-     * @param size
-     * @param type
-     * @param stride
-     * @param offset
-     */
-    protected void setPointAttribute(int vboId, int size, int type,
-                                   int stride, int offset) {
+  /**
+   *
+   * @param vboId
+   * @param size
+   * @param type
+   * @param stride
+   * @param offset
+   */
+  protected void setPointAttribute(int vboId, int size, int type,
+    int stride, int offset) {
     setAttributeVBO(offsetLoc, vboId, size, type, false, stride, offset);
   }
 
-
   // ***************************************************************************
   //
   // Class to store a user-specified value for a uniform parameter
   // in the shader
-
-    /**
-     *
-     */
+  /**
+   *
+   */
   protected static class UniformValue {
-    static final int INT1      = 0;
-    static final int INT2      = 1;
-    static final int INT3      = 2;
-    static final int INT4      = 3;
-    static final int FLOAT1    = 4;
-    static final int FLOAT2    = 5;
-    static final int FLOAT3    = 6;
-    static final int FLOAT4    = 7;
-    static final int INT1VEC   = 8;
-    static final int INT2VEC   = 9;
-    static final int INT3VEC   = 10;
-    static final int INT4VEC   = 11;
+
+    static final int INT1 = 0;
+    static final int INT2 = 1;
+    static final int INT3 = 2;
+    static final int INT4 = 3;
+    static final int FLOAT1 = 4;
+    static final int FLOAT2 = 5;
+    static final int FLOAT3 = 6;
+    static final int FLOAT4 = 7;
+    static final int INT1VEC = 8;
+    static final int INT2VEC = 9;
+    static final int INT3VEC = 10;
+    static final int INT4VEC = 11;
     static final int FLOAT1VEC = 12;
     static final int FLOAT2VEC = 13;
     static final int FLOAT3VEC = 14;
     static final int FLOAT4VEC = 15;
-    static final int MAT2      = 16;
-    static final int MAT3      = 17;
-    static final int MAT4      = 18;
+    static final int MAT2 = 16;
+    static final int MAT3 = 17;
+    static final int MAT4 = 18;
     static final int SAMPLER2D = 19;
 
     int type;