Merge pull request #101 from OpenGeoscience/version-0.3.9

Version 0.3.9.

Author: manthey

package.json

@@ -1,7 +1,7 @@
 {
   "name": "vgl",
   "description": "VTK for the Web.",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

vgl.js

@@ -104,7 +104,7 @@ if (!Math.log2) {
   };
 }
 
-vgl.version = '0.3.8';
+vgl.version = '0.3.9';
 
 //////////////////////////////////////////////////////////////////////////////
 /**
@@ -8836,7 +8836,7 @@ vgl.uniform = function (type, name) {
   'use strict';
 
   if (!(this instanceof vgl.uniform)) {
-    return new vgl.uniform();
+    return new vgl.uniform(type, name);
   }
 
   this.getTypeNumberOfComponents = function (type) {
@@ -8919,25 +8919,9 @@ vgl.uniform = function (type, name) {
    */
   /////////////////////////////////////////////////////////////////////////////
   this.set = function (value) {
-    var i = 0;
-    if (m_dataArray.length === 16) {
-      for (i = 0; i < 16; i += 1) {
-        m_dataArray[i] = value[i];
-      }
-    } else if (m_dataArray.length === 9) {
-      for (i = 0; i < 9; i += 1) {
-        m_dataArray[i] = value[i];
-      }
-    } else if (m_dataArray.length === 4) {
-      for (i = 0; i < 4; i += 1) {
-        m_dataArray[i] = value[i];
-      }
-    } else if (m_dataArray.length === 3) {
-      for (i = 0; i < 3; i += 1) {
-        m_dataArray[i] = value[i];
-      }
-    } else if (m_dataArray.length === 2) {
-      for (i = 0; i < 2; i += 1) {
+    var i = 0, lendata = m_dataArray.length;
+    if (lendata !== 1) {
+      for (i = 0; i < lendata; i += 1) {
         m_dataArray[i] = value[i];
       }
     } else {
@@ -8953,10 +8937,6 @@ vgl.uniform = function (type, name) {
    */
   /////////////////////////////////////////////////////////////////////////////
   this.callGL = function (renderState, location) {
-    if (this.m_numberElements < 1) {
-      return;
-    }
-
     switch (m_type) {
       case vgl.GL.BOOL:
       case vgl.GL.INT:
@@ -8965,12 +8945,24 @@ vgl.uniform = function (type, name) {
       case vgl.GL.FLOAT:
         renderState.m_context.uniform1fv(location, m_dataArray);
         break;
+      case vgl.GL.BOOL_VEC2:
+      case vgl.GL.INT_VEC2:
+        renderState.m_context.uniform2iv(location, m_dataArray);
+        break;
       case vgl.GL.FLOAT_VEC2:
         renderState.m_context.uniform2fv(location, m_dataArray);
         break;
+      case vgl.GL.BOOL_VEC3:
+      case vgl.GL.INT_VEC3:
+        renderState.m_context.uniform3iv(location, m_dataArray);
+        break;
       case vgl.GL.FLOAT_VEC3:
         renderState.m_context.uniform3fv(location, m_dataArray);
         break;
+      case vgl.GL.BOOL_VEC4:
+      case vgl.GL.INT_VEC4:
+        renderState.m_context.uniform4iv(location, m_dataArray);
+        break;
       case vgl.GL.FLOAT_VEC4:
         renderState.m_context.uniform4fv(location, m_dataArray);
         break;
@@ -8996,8 +8988,8 @@ vgl.uniform = function (type, name) {
    */
   /////////////////////////////////////////////////////////////////////////////
   this.update = function (renderState, program) {
-    renderState = renderState; /* unused parameter */
-    program = program; /* unused parameter */
+    void renderState; /* unused parameter */
+    void program; /* unused parameter */
     // Should be implemented by the derived class
   };
 
@@ -9019,7 +9011,7 @@ vgl.modelViewUniform = function (name) {
     return new vgl.modelViewUniform(name);
   }
 
-  if (name.length === 0) {
+  if (!name) {
     name = 'modelViewMatrix';
   }
 
@@ -9036,7 +9028,7 @@ vgl.modelViewUniform = function (name) {
    */
   /////////////////////////////////////////////////////////////////////////////
   this.update = function (renderState, program) {
-    program = program; /* unused parameter */
+    void program; /* unused parameter */
     this.set(renderState.m_modelViewMatrix);
   };
 
@@ -9061,7 +9053,7 @@ vgl.modelViewOriginUniform = function (name, origin) {
     return new vgl.modelViewOriginUniform(name, origin);
   }
 
-  if (name.length === 0) {
+  if (!name) {
     name = 'modelViewMatrix';
   }
   origin = origin || [0, 0, 0];
@@ -9094,18 +9086,23 @@ vgl.modelViewOriginUniform = function (name, origin) {
    */
   /////////////////////////////////////////////////////////////////////////////
   this.update = function (renderState, program) {
-    program = program; /* unused parameter */
-    var view = mat4.create();
-    mat4.translate(view, renderState.m_modelViewMatrix, m_origin);
+    void program; /* unused parameter */
+    var view = renderState.m_modelViewMatrix;
     if (renderState.m_modelViewAlignment) {
+      /* adjust alignment before origin.  Otherwise, a changing origin can
+       * affect the rounding choice and result in a 1 pixe jitter. */
       var align = renderState.m_modelViewAlignment;
+      /* Don't modify the orignal matrix.  If we are in an environment where
+       * you can't slice an Float32Array, switch to a regular array */
+      view = view.slice ? view.slice() : Array.prototype.slice.call(view);
       /* view[12] and view[13] are the x and y offsets.  align.round is the
        * units-per-pixel, and align.dx and .dy are either 0 or half the size of
        * a unit-per-pixel.  The alignment guarantees that the texels are
        * aligned with screen pixels. */
       view[12] = Math.round(view[12] / align.roundx) * align.roundx + align.dx;
       view[13] = Math.round(view[13] / align.roundy) * align.roundy + align.dy;
     }
+    view = mat4.translate(mat4.create(), view, m_origin);
     this.set(view);
   };
 
@@ -9129,7 +9126,7 @@ vgl.projectionUniform = function (name) {
     return new vgl.projectionUniform(name);
   }
 
-  if (name.length === 0) {
+  if (!name) {
     name = 'projectionMatrix';
   }
 
@@ -9146,7 +9143,7 @@ vgl.projectionUniform = function (name) {
    */
   /////////////////////////////////////////////////////////////////////////////
   this.update = function (renderState, program) {
-    program = program; /* unused parameter */
+    void program; /* unused parameter */
     this.set(renderState.m_projectionMatrix);
   };
 
@@ -9171,7 +9168,7 @@ vgl.floatUniform = function (name, value) {
     return new vgl.floatUniform(name, value);
   }
 
-  if (name.length === 0) {
+  if (!name) {
     name = 'floatUniform';
   }
 
@@ -9199,7 +9196,7 @@ vgl.normalMatrixUniform = function (name) {
     return new vgl.normalMatrixUniform(name);
   }
 
-  if (name.length === 0) {
+  if (!name) {
     name = 'normalMatrix';
   }
 
@@ -9216,7 +9213,7 @@ vgl.normalMatrixUniform = function (name) {
    */
   /////////////////////////////////////////////////////////////////////////////
   this.update = function (renderState, program) {
-    program = program; /* unused parameter */
+    void program; /* unused parameter */
     this.set(renderState.m_normalMatrix);
   };