zincjs 1.3.1 → 1.3.3

package/src/utilities.js

@@ -1,4 +1,5 @@
 const THREE = require('three');
+const THREEGeometry = require('./three/Geometry').Geometry;
 
 function resolveURL(url) {
 	let actualURL = url;
@@ -16,6 +17,7 @@ function resolveURL(url) {
 	return actualURL;
 }
 
+
 //Convenient function
 function loadExternalFile(url, data, callback, errorCallback) {
     // Set up an asynchronous request
@@ -81,218 +83,264 @@ exports.getColorsRGB = (colors, index) => {
     return [mycolor.r, mycolor.g, mycolor.b];
 }
 
+exports.updateMorphColorAttribute = function(targetGeometry, morph) {
+  if (morph && targetGeometry && targetGeometry.morphAttributes &&
+    targetGeometry.morphAttributes[ "color" ]) {
+    const morphColors = targetGeometry.morphAttributes[ "color" ];
+    const influences = morph.morphTargetInfluences;
+    const length = influences.length;
+    targetGeometry.deleteAttribute( 'morphColor0' );
+    targetGeometry.deleteAttribute( 'morphColor1' );
+    let bound = 0;
+    let morphArray = [];
+    for (let i = 0; (1 > bound) || (i < length); i++) {
+      if (influences[i] > 0) {
+        bound++;
+        morphArray.push([i, influences[i]]);
+      }
+    }
+    if (morphArray.length == 2) {
+      targetGeometry.setAttribute('morphColor0', morphColors[ morphArray[0][0] ] );
+      targetGeometry.setAttribute('morphColor1', morphColors[ morphArray[1][0] ] );
+    } else if (morphArray.length == 1) {
+      targetGeometry.setAttribute('morphColor0', morphColors[ morphArray[0][0] ] );
+      targetGeometry.setAttribute('morphColor1', morphColors[ morphArray[0][0] ] );
+    }
+  }
+}
+
+
+exports.toBufferGeometry = (geometryIn, options) => {
+  let geometry = undefined;
+  if (geometryIn instanceof THREEGeometry) {
+    if (options.localTimeEnabled && !geometryIn.morphNormalsReady && 
+      (geometryIn.morphNormals == undefined || geometryIn.morphNormals.length == 0))
+      geometryIn.computeMorphNormals();
+    geometry = geometryIn.toIndexedBufferGeometry();
+    if (options.localMorphColour) {
+      copyMorphColorsToIndexedBufferGeometry(geometryIn, geometry);
+    }
+  } else if (geometryIn instanceof THREE.BufferGeometry) {
+    geometry = geometryIn.clone();
+  }
+  geometry.colorsNeedUpdate = true;
+  geometry.computeBoundingBox();
+  geometry.computeBoundingSphere();
+  if (geometryIn._video)
+    geometry._video = geometryIn._video;
+  return geometry;
+}
 
 exports.copyMorphColorsToBufferGeometry = (geometry, bufferGeometry) => {
-    if (geometry && geometry.morphColors && geometry.morphColors.length > 0 ) {
-      let array = [];
-      let morphColors = geometry.morphColors;
-      const getColorsRGB = require("./utilities").getColorsRGB;
-      for ( var i = 0, l = morphColors.length; i < l; i ++ ) {
-        let morphColor = morphColors[ i ];
-        let colorArray = [];
-		    for ( var j = 0; j < geometry.faces.length; j ++ ) {
-          let face = geometry.faces[j];
-          let color = getColorsRGB(morphColor.colors, face.a);
-          colorArray.push(color[0], color[1], color[2]);
-          color = getColorsRGB(morphColor.colors, face.b);
-          colorArray.push(color[0], color[1], color[2]);
-          color = getColorsRGB(morphColor.colors, face.c);
-          colorArray.push(color[0], color[1], color[2]);
-        }
-        var attribute = new THREE.Float32BufferAttribute( geometry.faces.length * 3 * 3, 3 );
-        attribute.name = morphColor.name;
-        array.push( attribute.copyArray( colorArray ) );
+  if (geometry && geometry.morphColors && geometry.morphColors.length > 0 ) {
+    let array = [];
+    let morphColors = geometry.morphColors;
+    const getColorsRGB = require("./utilities").getColorsRGB;
+    for ( var i = 0, l = morphColors.length; i < l; i ++ ) {
+      let morphColor = morphColors[ i ];
+      let colorArray = [];
+      for ( var j = 0; j < geometry.faces.length; j ++ ) {
+        let face = geometry.faces[j];
+        let color = getColorsRGB(morphColor.colors, face.a);
+        colorArray.push(color[0], color[1], color[2]);
+        color = getColorsRGB(morphColor.colors, face.b);
+        colorArray.push(color[0], color[1], color[2]);
+        color = getColorsRGB(morphColor.colors, face.c);
+        colorArray.push(color[0], color[1], color[2]);
       }
-      bufferGeometry.morphAttributes[ "color" ] = array; 
+      var attribute = new THREE.Float32BufferAttribute( geometry.faces.length * 3 * 3, 3 );
+      attribute.name = morphColor.name;
+      array.push( attribute.copyArray( colorArray ) );
     }
+    bufferGeometry.morphAttributes[ "color" ] = array; 
   }
+}
 
 
-  exports.copyMorphColorsToIndexedBufferGeometry = (geometry, bufferGeometry) => {
-    if (geometry && geometry.morphColors && geometry.morphColors.length > 0 ) {
-      let array = [];
-      let morphColors = geometry.morphColors;
-      const getColorsRGB = require("./utilities").getColorsRGB;
-      for ( let i = 0, l = morphColors.length; i < l; i ++ ) {
-        const morphColor = morphColors[ i ];
-        const colorArray = [];
-		    for ( let j = 0; j < morphColor.colors.length * 3; j ++ ) {
-          let color = getColorsRGB(morphColor.colors, j);
-          colorArray.push(color[0], color[1], color[2]);
-        }
-        const attribute = new THREE.Float32BufferAttribute( colorArray, 3 );
-        attribute.name = morphColor.name;
-        array.push( attribute );
+const copyMorphColorsToIndexedBufferGeometry = (geometry, bufferGeometry) => {
+  if (geometry && geometry.morphColors && geometry.morphColors.length > 0 ) {
+    let array = [];
+    let morphColors = geometry.morphColors;
+    const getColorsRGB = require("./utilities").getColorsRGB;
+    for ( let i = 0, l = morphColors.length; i < l; i ++ ) {
+      const morphColor = morphColors[ i ];
+      const colorArray = [];
+      for ( let j = 0; j < morphColor.colors.length * 3; j ++ ) {
+        let color = getColorsRGB(morphColor.colors, j);
+        colorArray.push(color[0], color[1], color[2]);
       }
-      bufferGeometry.morphAttributes[ "color" ] = array; 
+      const attribute = new THREE.Float32BufferAttribute( colorArray, 3 );
+      attribute.name = morphColor.name;
+      array.push( attribute );
     }
+    bufferGeometry.morphAttributes[ "color" ] = array; 
   }
+}
 
-  exports.mergeVertices = ( geometry, tolerance = 1e-4 ) => {
-
-    tolerance = Math.max( tolerance, Number.EPSILON );
+exports.mergeVertices = ( geometry, tolerance = 1e-4 ) => {
 
-    // Generate an index buffer if the geometry doesn't have one, or optimize it
-    // if it's already available.
-    var hashToIndex = {};
-    var indices = geometry.getIndex();
-    var positions = geometry.getAttribute( 'position' );
-    var vertexCount = indices ? indices.count : positions.count;
+  tolerance = Math.max( tolerance, Number.EPSILON );
 
-    // next value for triangle indices
-    var nextIndex = 0;
+  // Generate an index buffer if the geometry doesn't have one, or optimize it
+  // if it's already available.
+  var hashToIndex = {};
+  var indices = geometry.getIndex();
+  var positions = geometry.getAttribute( 'position' );
+  var vertexCount = indices ? indices.count : positions.count;
 
-    // attributes and new attribute arrays
-    var attributeNames = Object.keys( geometry.attributes );
-    var attrArrays = {};
-    var morphAttrsArrays = {};
-    var newIndices = [];
-    var getters = [ 'getX', 'getY', 'getZ', 'getW' ];
+  // next value for triangle indices
+  var nextIndex = 0;
 
-    // initialize the arrays
-    for ( var i = 0, l = attributeNames.length; i < l; i ++ ) {
-        var name = attributeNames[ i ];
+  // attributes and new attribute arrays
+  var attributeNames = Object.keys( geometry.attributes );
+  var attrArrays = {};
+  var morphAttrsArrays = {};
+  var newIndices = [];
+  var getters = [ 'getX', 'getY', 'getZ', 'getW' ];
 
-        attrArrays[ name ] = [];
+  // initialize the arrays
+  for ( var i = 0, l = attributeNames.length; i < l; i ++ ) {
+      var name = attributeNames[ i ];
 
-        var morphAttr = geometry.morphAttributes[ name ];
-        if ( morphAttr ) {
+      attrArrays[ name ] = [];
 
-            morphAttrsArrays[ name ] = new Array( morphAttr.length ).fill().map( () => [] );
+      var morphAttr = geometry.morphAttributes[ name ];
+      if ( morphAttr ) {
 
-        }
+          morphAttrsArrays[ name ] = new Array( morphAttr.length ).fill().map( () => [] );
 
-    }
+      }
 
-    // convert the error tolerance to an amount of decimal places to truncate to
-    var decimalShift = Math.log10( 1 / tolerance );
-    var shiftMultiplier = Math.pow( 10, decimalShift );
-    for ( var i = 0; i < vertexCount; i ++ ) {
+  }
 
-        var index = indices ? indices.getX( i ) : i;
+  // convert the error tolerance to an amount of decimal places to truncate to
+  var decimalShift = Math.log10( 1 / tolerance );
+  var shiftMultiplier = Math.pow( 10, decimalShift );
+  for ( var i = 0; i < vertexCount; i ++ ) {
 
-        // Generate a hash for the vertex attributes at the current index 'i'
-        var hash = '';
-        for ( var j = 0, l = attributeNames.length; j < l; j ++ ) {
+      var index = indices ? indices.getX( i ) : i;
 
-            var name = attributeNames[ j ];
-            var attribute = geometry.getAttribute( name );
-            var itemSize = attribute.itemSize;
+      // Generate a hash for the vertex attributes at the current index 'i'
+      var hash = '';
+      for ( var j = 0, l = attributeNames.length; j < l; j ++ ) {
 
-            for ( var k = 0; k < itemSize; k ++ ) {
+          var name = attributeNames[ j ];
+          var attribute = geometry.getAttribute( name );
+          var itemSize = attribute.itemSize;
 
-                // double tilde truncates the decimal value
-                hash += `${ ~ ~ ( attribute[ getters[ k ] ]( index ) * shiftMultiplier ) },`;
+          for ( var k = 0; k < itemSize; k ++ ) {
 
-            }
+              // double tilde truncates the decimal value
+              hash += `${ ~ ~ ( attribute[ getters[ k ] ]( index ) * shiftMultiplier ) },`;
 
-        }
+          }
 
-        // Add another reference to the vertex if it's already
-        // used by another index
-        if ( hash in hashToIndex ) {
+      }
 
-            newIndices.push( hashToIndex[ hash ] );
+      // Add another reference to the vertex if it's already
+      // used by another index
+      if ( hash in hashToIndex ) {
 
-        } else {
+          newIndices.push( hashToIndex[ hash ] );
 
-            // copy data to the new index in the attribute arrays
-            for ( var j = 0, l = attributeNames.length; j < l; j ++ ) {
+      } else {
 
-                var name = attributeNames[ j ];
-                var attribute = geometry.getAttribute( name );
-                var morphAttr = geometry.morphAttributes[ name ];
-                var itemSize = attribute.itemSize;
-                var newarray = attrArrays[ name ];
-                var newMorphArrays = morphAttrsArrays[ name ];
+          // copy data to the new index in the attribute arrays
+          for ( var j = 0, l = attributeNames.length; j < l; j ++ ) {
 
-                for ( var k = 0; k < itemSize; k ++ ) {
+              var name = attributeNames[ j ];
+              var attribute = geometry.getAttribute( name );
+              var morphAttr = geometry.morphAttributes[ name ];
+              var itemSize = attribute.itemSize;
+              var newarray = attrArrays[ name ];
+              var newMorphArrays = morphAttrsArrays[ name ];
 
-                    var getterFunc = getters[ k ];
-                    newarray.push( attribute[ getterFunc ]( index ) );
+              for ( var k = 0; k < itemSize; k ++ ) {
 
-                    if ( morphAttr ) {
+                  var getterFunc = getters[ k ];
+                  newarray.push( attribute[ getterFunc ]( index ) );
 
-                        for ( var m = 0, ml = morphAttr.length; m < ml; m ++ ) {
+                  if ( morphAttr ) {
 
-                            newMorphArrays[ m ].push( morphAttr[ m ][ getterFunc ]( index ) );
+                      for ( var m = 0, ml = morphAttr.length; m < ml; m ++ ) {
 
-                        }
+                          newMorphArrays[ m ].push( morphAttr[ m ][ getterFunc ]( index ) );
 
-                    }
+                      }
 
-                }
+                  }
 
-            }
+              }
 
-            hashToIndex[ hash ] = nextIndex;
-            newIndices.push( nextIndex );
-            nextIndex ++;
+          }
 
-        }
+          hashToIndex[ hash ] = nextIndex;
+          newIndices.push( nextIndex );
+          nextIndex ++;
 
-    }
+      }
 
-    // Generate typed arrays from new attribute arrays and update
-    // the attributeBuffers
-    const result = geometry.clone();
-    for ( var i = 0, l = attributeNames.length; i < l; i ++ ) {
+  }
 
-        var name = attributeNames[ i ];
-        var oldAttribute = geometry.getAttribute( name );
-        var attribute;
+  // Generate typed arrays from new attribute arrays and update
+  // the attributeBuffers
+  const result = geometry.clone();
+  for ( var i = 0, l = attributeNames.length; i < l; i ++ ) {
 
-        var buffer = new oldAttribute.array.constructor( attrArrays[ name ] );
-        if ( oldAttribute.isInterleavedBufferAttribute ) {
+      var name = attributeNames[ i ];
+      var oldAttribute = geometry.getAttribute( name );
+      var attribute;
 
-            attribute = new THREE.BufferAttribute( buffer, oldAttribute.itemSize, oldAttribute.itemSize );
+      var buffer = new oldAttribute.array.constructor( attrArrays[ name ] );
+      if ( oldAttribute.isInterleavedBufferAttribute ) {
 
-        } else {
+          attribute = new THREE.BufferAttribute( buffer, oldAttribute.itemSize, oldAttribute.itemSize );
 
-            attribute = geometry.getAttribute( name ).clone();
-            attribute.setArray( buffer );
+      } else {
 
-        }
+          attribute = geometry.getAttribute( name ).clone();
+          attribute.setArray( buffer );
 
-        result.setAttribute( name, attribute );
+      }
 
-        // Update the attribute arrays
-        if ( name in morphAttrsArrays ) {
+      result.setAttribute( name, attribute );
 
-            for ( var j = 0; j < morphAttrsArrays[ name ].length; j ++ ) {
+      // Update the attribute arrays
+      if ( name in morphAttrsArrays ) {
 
-                var morphAttribute = geometry.morphAttributes[ name ][ j ].clone();
-                morphAttribute.setArray( new morphAttribute.array.constructor( morphAttrsArrays[ name ][ j ] ) );
-                result.morphAttributes[ name ][ j ] = morphAttribute;
+          for ( var j = 0; j < morphAttrsArrays[ name ].length; j ++ ) {
 
-            }
+              var morphAttribute = geometry.morphAttributes[ name ][ j ].clone();
+              morphAttribute.setArray( new morphAttribute.array.constructor( morphAttrsArrays[ name ][ j ] ) );
+              result.morphAttributes[ name ][ j ] = morphAttribute;
 
-        }
+          }
 
-    }
+      }
 
-    // Generate an index buffer typed array
-    var cons = Uint8Array;
-    if ( newIndices.length >= Math.pow( 2, 8 ) ) cons = Uint16Array;
-    if ( newIndices.length >= Math.pow( 2, 16 ) ) cons = Uint32Array;
+  }
 
-    var newIndexBuffer = new cons( newIndices );
-    var newIndices = null;
-    if ( indices === null ) {
+  // Generate an index buffer typed array
+  var cons = Uint8Array;
+  if ( newIndices.length >= Math.pow( 2, 8 ) ) cons = Uint16Array;
+  if ( newIndices.length >= Math.pow( 2, 16 ) ) cons = Uint32Array;
 
-        newIndices = new THREE.BufferAttribute( newIndexBuffer, 1 );
+  var newIndexBuffer = new cons( newIndices );
+  var newIndices = null;
+  if ( indices === null ) {
 
-    } else {
+      newIndices = new THREE.BufferAttribute( newIndexBuffer, 1 );
 
-        newIndices = geometry.getIndex().clone();
-        newIndices.setArray( newIndexBuffer );
+  } else {
 
-    }
+      newIndices = geometry.getIndex().clone();
+      newIndices.setArray( newIndexBuffer );
 
-    result.setIndex( newIndices );
+  }
 
-    return result;
+  result.setIndex( newIndices );
 
+  return result;
 }
 
 function PhongToToon(materialIn) {