propane 2.9.0-java → 2.9.1-java

data/src/main/java/processing/data/Sort.java

@@ -41,6 +41,6 @@ public abstract class Sort implements Runnable {
 
 
   abstract public int size();
-  abstract public float compare(int a, int b);
+  abstract public int compare(int a, int b);
   abstract public void swap(int a, int b);
 }

data/src/main/java/processing/data/StringDict.java

@@ -522,7 +522,7 @@ public class StringDict {
       }
 
       @Override
-      public float compare(int a, int b) {
+      public int compare(int a, int b) {
         int diff = 0;
         if (useKeys) {
           diff = keys[a].compareToIgnoreCase(keys[b]);
@@ -571,8 +571,17 @@ public class StringDict {
 
 
   /**
-   * Write tab-delimited entries out to
-   * @param writer
+   * Save tab-delimited entries to a file (TSV format, UTF-8 encoding)
+   */
+  public void save(File file) {
+    PrintWriter writer = PApplet.createWriter(file);
+    write(writer);
+    writer.close();
+  }
+
+
+  /**
+   * Write tab-delimited entries to a PrintWriter
    */
   public void write(PrintWriter writer) {
     for (int i = 0; i < count; i++) {

data/src/main/java/processing/data/StringList.java

@@ -1,5 +1,7 @@
 package processing.data;
 
+import java.io.File;
+import java.io.PrintWriter;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.Random;
@@ -514,8 +516,8 @@ public class StringList implements Iterable<String> {
       }
 
       @Override
-      public float compare(int a, int b) {
-        float diff = data[a].compareToIgnoreCase(data[b]);
+      public int compare(int a, int b) {
+        int diff = data[a].compareToIgnoreCase(data[b]);
         return reverse ? -diff : diff;
       }
 
@@ -756,6 +758,27 @@ public class StringList implements Iterable<String> {
   }
 
 
+  /**
+   * Save tab-delimited entries to a file (TSV format, UTF-8 encoding)
+   */
+  public void save(File file) {
+    PrintWriter writer = PApplet.createWriter(file);
+    write(writer);
+    writer.close();
+  }
+
+
+  /**
+   * Write entries to a PrintWriter, one per line
+   */
+  public void write(PrintWriter writer) {
+    for (int i = 0; i < count; i++) {
+      writer.println(data[i]);
+    }
+    writer.flush();
+  }
+
+
   /**
    * Return this dictionary as a String in JSON format.
    */

data/src/main/java/processing/data/Table.java

@@ -4333,7 +4333,7 @@ public class Table {
       }
 
       @Override
-      public float compare(int index1, int index2) {
+      public int compare(int index1, int index2) {
         int a = reverse ? order[index2] : order[index1];
         int b = reverse ? order[index1] : order[index2];
 
@@ -4341,13 +4341,24 @@ public class Table {
         case INT:
           return getInt(a, column) - getInt(b, column);
         case LONG:
-          return getLong(a, column) - getLong(b, column);
+          long diffl = getLong(a, column) - getLong(b, column);
+          return diffl == 0 ? 0 : (diffl < 0 ? -1 : 1);
         case FLOAT:
-          return getFloat(a, column) - getFloat(b, column);
+          float difff = getFloat(a, column) - getFloat(b, column);
+          return difff == 0 ? 0 : (difff < 0 ? -1 : 1);
         case DOUBLE:
-          return (float) (getDouble(a, column) - getDouble(b, column));
+          double diffd = getDouble(a, column) - getDouble(b, column);
+          return diffd == 0 ? 0 : (diffd < 0 ? -1 : 1);
         case STRING:
-          return getString(a, column).compareToIgnoreCase(getString(b, column));
+          String string1 = getString(a, column);
+          if (string1 == null) {
+            string1 = "";  // avoid NPE when cells are left empty
+          }
+          String string2 = getString(b, column);
+          if (string2 == null) {
+            string2 = "";
+          }
+          return string1.compareToIgnoreCase(string2);
         case CATEGORY:
           return getInt(a, column) - getInt(b, column);
         default:

data/src/main/java/processing/data/XML.java

@@ -594,7 +594,14 @@ public class XML implements Serializable {
     children = null;  // TODO not efficient
   }
 
-
+  /**
+   * Removes whitespace nodes.
+   * Those whitespace nodes are required to reconstruct the original XML's spacing and indentation.
+   * If you call this and use saveXML() your original spacing will be gone.
+   * 
+   * @nowebref
+   * @brief Removes whitespace nodes
+   */
   public void trim() {
     try {
       XPathFactory xpathFactory = XPathFactory.newInstance();

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

@@ -1287,9 +1287,9 @@ public abstract class PGL {
     PGL ppgl = primaryPGL ? this : graphics.getPrimaryPGL();
 
     if (!ppgl.loadedTex2DShader || ppgl.tex2DShaderContext != ppgl.glContext) {
-      String[] preprocVertSrc = preprocessVertexSource(texVertShaderSource, getGLSLVersion());
+      String[] preprocVertSrc = preprocessVertexSource(texVertShaderSource, getGLSLVersion(), getGLSLVersionSuffix());
       String vertSource = PApplet.join(preprocVertSrc, "\n");
-      String[] preprocFragSrc = preprocessFragmentSource(tex2DFragShaderSource, getGLSLVersion());
+      String[] preprocFragSrc = preprocessFragmentSource(tex2DFragShaderSource, getGLSLVersion(), getGLSLVersionSuffix());
       String fragSource = PApplet.join(preprocFragSrc, "\n");
       ppgl.tex2DVertShader = createShader(VERTEX_SHADER, vertSource);
       ppgl.tex2DFragShader = createShader(FRAGMENT_SHADER, fragSource);
@@ -1419,9 +1419,9 @@ public abstract class PGL {
     PGL ppgl = primaryPGL ? this : graphics.getPrimaryPGL();
 
     if (!ppgl.loadedTexRectShader || ppgl.texRectShaderContext != ppgl.glContext) {
-      String[] preprocVertSrc = preprocessVertexSource(texVertShaderSource, getGLSLVersion());
+      String[] preprocVertSrc = preprocessVertexSource(texVertShaderSource, getGLSLVersion(), getGLSLVersionSuffix());
       String vertSource = PApplet.join(preprocVertSrc, "\n");
-      String[] preprocFragSrc = preprocessFragmentSource(texRectFragShaderSource, getGLSLVersion());
+      String[] preprocFragSrc = preprocessFragmentSource(texRectFragShaderSource, getGLSLVersion(), getGLSLVersionSuffix());
       String fragSource = PApplet.join(preprocFragSrc, "\n");
       ppgl.texRectVertShader = createShader(VERTEX_SHADER, vertSource);
       ppgl.texRectFragShader = createShader(FRAGMENT_SHADER, fragSource);
@@ -1848,6 +1848,7 @@ public abstract class PGL {
 
 
   abstract protected int getGLSLVersion();
+  abstract protected String getGLSLVersionSuffix();
 
 
   protected String[] loadVertexShader(String filename) {
@@ -1880,28 +1881,29 @@ public abstract class PGL {
   }
 
 
-  protected String[] loadVertexShader(String filename, int version) {
+  protected String[] loadVertexShader(String filename, int version, String versionSuffix) {
     return loadVertexShader(filename);
   }
 
 
-  protected String[] loadFragmentShader(String filename, int version) {
+  protected String[] loadFragmentShader(String filename, int version, String versionSuffix) {
     return loadFragmentShader(filename);
   }
 
 
-  protected String[] loadFragmentShader(URL url, int version) {
+  protected String[] loadFragmentShader(URL url, int version, String versionSuffix) {
     return loadFragmentShader(url);
   }
 
 
-  protected String[] loadVertexShader(URL url, int version) {
+  protected String[] loadVertexShader(URL url, int version, String versionSuffix) {
     return loadVertexShader(url);
   }
 
 
   protected static String[] preprocessFragmentSource(String[] fragSrc0,
-                                                     int version) {
+                                                     int version,
+                                                     String versionSuffix) {
     if (containsVersionDirective(fragSrc0)) {
       // The user knows what she or he is doing
       return fragSrc0;
@@ -1915,7 +1917,7 @@ public abstract class PGL {
       int offset = 1;
 
       fragSrc = preprocessShaderSource(fragSrc0, search, replace, offset);
-      fragSrc[0] = "#version " + version;
+      fragSrc[0] = "#version " + version + versionSuffix;
     } else {
       // We need to replace 'texture' uniform by 'texMap' uniform and
       // 'textureXXX()' functions by 'texture()' functions. Order of these
@@ -1932,15 +1934,20 @@ public abstract class PGL {
       int offset = 2;
 
       fragSrc = preprocessShaderSource(fragSrc0, search, replace, offset);
-      fragSrc[0] = "#version " + version;
-      fragSrc[1] = "out vec4 _fragColor;";
+      fragSrc[0] = "#version " + version + versionSuffix;
+      if (" es".equals(versionSuffix)) {
+        fragSrc[1] = "out mediump vec4 _fragColor;";
+      } else {
+        fragSrc[1] = "out vec4 _fragColor;";
+      }
     }
 
     return fragSrc;
   }
 
   protected static String[] preprocessVertexSource(String[] vertSrc0,
-                                                   int version) {
+                                                   int version,
+                                                   String versionSuffix) {
     if (containsVersionDirective(vertSrc0)) {
       // The user knows what she or he is doing
       return vertSrc0;
@@ -1954,7 +1961,7 @@ public abstract class PGL {
       int offset = 1;
 
       vertSrc = preprocessShaderSource(vertSrc0, search, replace, offset);
-      vertSrc[0] = "#version " + version;
+      vertSrc[0] = "#version " + version + versionSuffix;
     } else {
       // We need to replace 'texture' uniform by 'texMap' uniform and
       // 'textureXXX()' functions by 'texture()' functions. Order of these
@@ -1971,7 +1978,7 @@ public abstract class PGL {
       int offset = 1;
 
       vertSrc = preprocessShaderSource(vertSrc0, search, replace, offset);
-      vertSrc[0] = "#version " + version;
+      vertSrc[0] = "#version " + version + versionSuffix;
     }
 
     return vertSrc;
@@ -2225,7 +2232,7 @@ public abstract class PGL {
 
   protected boolean hasAnisoSamplingSupport() {
     int major = getGLVersion()[0];
-    if (major < 3) {
+    if (isES() || major < 3) {
       String ext = getString(EXTENSIONS);
       return -1 < ext.indexOf("_texture_filter_anisotropic");
     } else {

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

@@ -1561,13 +1561,14 @@ public class PGraphicsOpenGL extends PGraphics {
     }
     pgl.depthFunc(PGL.LEQUAL);
 
-    if (OPENGL_RENDERER.equals("VideoCore IV HW")) {
-      // Broadcom's VC IV driver is unhappy with either of these
-      // ignore for now
+    if (pgl.isES()) {
+      // neither GL_MULTISAMPLE nor GL_POLYGON_SMOOTH are part of GLES2 or GLES3
     } else if (smooth < 1) {
       pgl.disable(PGL.MULTISAMPLE);
     } else if (1 <= smooth) {
       pgl.enable(PGL.MULTISAMPLE);
+    }
+    if (!pgl.isES()) {
       pgl.disable(PGL.POLYGON_SMOOTH);
     }
 
@@ -6775,16 +6776,14 @@ public class PGraphicsOpenGL extends PGraphics {
 //        quality = temp;
 //      }
     }
-    if (OPENGL_RENDERER.equals("VideoCore IV HW")) {
-      // Broadcom's VC IV driver is unhappy with either of these
-      // ignore for now
+    if (pgl.isES()) {
+      // neither GL_MULTISAMPLE nor GL_POLYGON_SMOOTH are part of GLES2 or GLES3
     } else if (smooth < 1) {
       pgl.disable(PGL.MULTISAMPLE);
     } else if (1 <= smooth) {
       pgl.enable(PGL.MULTISAMPLE);
     }
-    // work around runtime exceptions in Broadcom's VC IV driver
-    if (false == OPENGL_RENDERER.equals("VideoCore IV HW")) {
+    if (!pgl.isES()) {
       pgl.disable(PGL.POLYGON_SMOOTH);
     }
 
@@ -6895,8 +6894,12 @@ public class PGraphicsOpenGL extends PGraphics {
 
     // overwrite the default shaders with vendor specific versions
     // if needed
-    if (OPENGL_RENDERER.equals("VideoCore IV HW") ||    // Broadcom's binary driver for Raspberry Pi
-      OPENGL_RENDERER.contains("VC4")) {   // Mesa driver for same hardware
+    if (OPENGL_RENDERER.equals("VideoCore IV HW")) {  // Broadcom's binary driver for Raspberry Pi
+        defLightShaderVertURL =
+          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-brcm.glsl");
+        defTexlightShaderVertURL =
+          PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/TexLightVert-brcm.glsl");
+    } else if (OPENGL_RENDERER.contains("VC4")) {     // Mesa driver for same hardware
         defLightShaderVertURL =
           PGraphicsOpenGL.class.getResource("/processing/opengl/shaders/LightVert-vc4.glsl");
         defTexlightShaderVertURL =

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

@@ -503,6 +503,7 @@ public class PJOGL extends PGL {
     return ((Font) font).deriveFont(size);
   }
 
+
   @Override
   protected int getGLSLVersion() {
     VersionNumber vn = context.getGLSLVersionNumber();
@@ -510,49 +511,60 @@ public class PJOGL extends PGL {
   }
 
 
+  @Override
+  protected String getGLSLVersionSuffix() {
+    VersionNumber vn = context.getGLSLVersionNumber();
+    if (context.isGLESProfile() && 1 < vn.getMajor()) {
+      return " es";
+    } else {
+      return "";
+    }
+  }
+
+
   @Override
   protected String[] loadVertexShader(String filename) {
-    return loadVertexShader(filename, getGLSLVersion());
+    return loadVertexShader(filename, getGLSLVersion(), getGLSLVersionSuffix());
   }
 
 
   @Override
   protected String[] loadFragmentShader(String filename) {
-    return loadFragmentShader(filename, getGLSLVersion());
+    return loadFragmentShader(filename, getGLSLVersion(), getGLSLVersionSuffix());
   }
 
 
   @Override
   protected String[] loadVertexShader(URL url) {
-    return loadVertexShader(url, getGLSLVersion());
+    return loadVertexShader(url, getGLSLVersion(), getGLSLVersionSuffix());
   }
 
 
   @Override
   protected String[] loadFragmentShader(URL url) {
-    return loadFragmentShader(url, getGLSLVersion());
+    return loadFragmentShader(url, getGLSLVersion(), getGLSLVersionSuffix());
   }
 
 
   @Override
-  protected String[] loadFragmentShader(String filename, int version) {
+  protected String[] loadFragmentShader(String filename, int version, String versionSuffix) {
     String[] fragSrc0 = sketch.loadStrings(filename);
-    return preprocessFragmentSource(fragSrc0, version);
+    return preprocessFragmentSource(fragSrc0, version, versionSuffix);
   }
 
 
   @Override
-  protected String[] loadVertexShader(String filename, int version) {
+  protected String[] loadVertexShader(String filename, int version, String versionSuffix) {
     String[] vertSrc0 = sketch.loadStrings(filename);
-    return preprocessVertexSource(vertSrc0, version);
+    return preprocessVertexSource(vertSrc0, version, versionSuffix);
   }
 
 
   @Override
-  protected String[] loadFragmentShader(URL url, int version) {
+  protected String[] loadFragmentShader(URL url, int version, String versionSuffix) {
     try {
       String[] fragSrc0 = PApplet.loadStrings(url.openStream());
-      return preprocessFragmentSource(fragSrc0, version);
+      return preprocessFragmentSource(fragSrc0, version, versionSuffix);
     } catch (IOException e) {
       PGraphics.showException("Cannot load fragment shader " + url.getFile());
     }
@@ -561,10 +573,10 @@ public class PJOGL extends PGL {
 
 
   @Override
-  protected String[] loadVertexShader(URL url, int version) {
+  protected String[] loadVertexShader(URL url, int version, String versionSuffix) {
     try {
       String[] vertSrc0 = PApplet.loadStrings(url.openStream());
-      return preprocessVertexSource(vertSrc0, version);
+      return preprocessVertexSource(vertSrc0, version, versionSuffix);
     } catch (IOException e) {
       PGraphics.showException("Cannot load vertex shader " + url.getFile());
     }
@@ -1926,6 +1938,8 @@ public class PJOGL extends PGL {
       gl2x.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
     } else if (gl3 != null) {
       gl3.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    } else if (gl3es3 != null) {
+      gl3es3.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
     } else {
       throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glBlitFramebuffer()"));
     }
@@ -1937,6 +1951,8 @@ public class PJOGL extends PGL {
       gl2x.glRenderbufferStorageMultisample(target, samples, format, width, height);
     } else if (gl3 != null) {
       gl3.glRenderbufferStorageMultisample(target, samples, format, width, height);
+    } else if (gl3es3 != null) {
+      gl3es3.glRenderbufferStorageMultisample(target, samples, format, width, height);
     } else {
       throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glRenderbufferStorageMultisample()"));
     }
@@ -1948,6 +1964,8 @@ public class PJOGL extends PGL {
       gl2x.glReadBuffer(buf);
     } else if (gl3 != null) {
       gl3.glReadBuffer(buf);
+    } else if (gl3es3 != null) {
+      gl3es3.glReadBuffer(buf);
     } else {
       throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glReadBuffer()"));
     }
@@ -1959,6 +1977,11 @@ public class PJOGL extends PGL {
       gl2x.glDrawBuffer(buf);
     } else if (gl3 != null) {
       gl3.glDrawBuffer(buf);
+    } else if (gl3es3 != null) {
+      IntBuffer intBuffer = IntBuffer.allocate(1);
+      intBuffer.put(buf);
+      intBuffer.rewind();
+      gl3es3.glDrawBuffers(1, intBuffer);
     } else {
       throw new RuntimeException(String.format(MISSING_GLFUNC_ERROR, "glDrawBuffer()"));
     }

data/src/main/java/processing/opengl/shaders/LightVert-brcm.glsl

@@ -0,0 +1,154 @@
+/*
+  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.0);
+const vec3 minus_one_vec3 = vec3(0.0-1.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 = minus_one_vec3 * 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 * minus_one_vec3;
+  
+  // 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);
+  
+  // prevent register allocation failure by limiting ourselves to
+  // two lights for now
+  for (int i = 0; i < 2; 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 = minus_one_vec3 * 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);
+}