zincjs 1.2.0 → 1.4.0-beta.0

package/src/sceneLoader.js

@@ -160,7 +160,7 @@ exports.SceneLoader = function (sceneIn) {
       if (morphColour != undefined && morphColour[i] != undefined)
         localMorphColour = morphColour[i] ? true : false;
       primitivesLoader.load(resolveURL(filename), meshloader(region, colour, opacity, localTimeEnabled, localMorphColour, undefined, undefined,
-        undefined, finishCallback), this.onProgress(i), this.onError(finishCallback));
+        undefined, undefined, finishCallback), this.onProgress(i), this.onError(finishCallback));
     }
   }
 
@@ -340,7 +340,7 @@ exports.SceneLoader = function (sceneIn) {
     const loader = new STLLoader();
     loader.crossOrigin = "Anonymous";
     loader.load(resolveURL(url), meshloader(region, colour, opacity, false,
-      false, groupName, undefined, undefined, finishCallback));
+      false, groupName, undefined, undefined, undefined, finishCallback));
   }
 
   /**
@@ -359,33 +359,7 @@ exports.SceneLoader = function (sceneIn) {
     const loader = new OBJLoader();
     loader.crossOrigin = "Anonymous";
     loader.load(resolveURL(url), meshloader(region, colour, opacity, false,
-      false, groupName, undefined, undefined,finishCallback));
-  }
-
-  //Loader for the OBJ format, 
-  const objloader = (
-    region,
-    colour,
-    opacity,
-    localTimeEnabled,
-    localMorphColour,
-    groupName,
-    finishCallback
-  ) => {
-    return object => {
-      this.toBeDownloaded--;
-      object.traverse(child => {
-        if (child instanceof THREE.Mesh) {
-          const zincGeometry = addMeshToZincGeometry(child, localTimeEnabled, localMorphColour);
-          region.addZincObject(zincGeometry);
-          if (zincGeometry.morph)
-            zincGeometry.morph.name = groupName;
-          zincGeometry.groupName = groupName;
-          if (finishCallback != undefined && (typeof finishCallback == 'function'))
-            finishCallback(zincGeometry);
-        }
-      });
-    };
+      false, groupName, undefined, undefined, undefined, finishCallback));
   }
 
   /**
@@ -422,19 +396,19 @@ exports.SceneLoader = function (sceneIn) {
       } else if (fileFormat == "OBJ") {
         loader = new OBJLoader();
         loader.crossOrigin = "Anonymous";
-        loader.load(url, objloader(region, colour, opacity, localTimeEnabled,
-          localMorphColour, groupName, anatomicalId, finishCallback), this.onProgress(i), this.onError);
+        loader.load(url, meshloader(region, colour, opacity, localTimeEnabled,
+          localMorphColour, groupName, anatomicalId, renderOrder, options, finishCallback), this.onProgress(i), this.onError);
         return;
       }
     }
     if (isInline) {
       const object = primitivesLoader.parse( url );
 			(meshloader(region, colour, opacity, localTimeEnabled,
-        localMorphColour, groupName, anatomicalId, renderOrder, finishCallback))( object.geometry, object.materials );
+        localMorphColour, groupName, anatomicalId, renderOrder, options, finishCallback))( object.geometry, object.materials );
     } else {
       loader.crossOrigin = "Anonymous";
       primitivesLoader.load(url, meshloader(region, colour, opacity, localTimeEnabled,
-        localMorphColour, groupName, anatomicalId, renderOrder, finishCallback), this.onProgress(i), this.onError(finishCallback));
+        localMorphColour, groupName, anatomicalId, renderOrder, options, finishCallback), this.onProgress(i), this.onError(finishCallback));
     }
   };
 
@@ -529,7 +503,7 @@ exports.SceneLoader = function (sceneIn) {
    * 
    * @returns {Zinc.Geometry}
    */
-  addZincGeometry = (
+  createZincGeometry = (
     region,
     geometryIn,
     colour,
@@ -547,7 +521,7 @@ exports.SceneLoader = function (sceneIn) {
     options.localMorphColour = localMorphColour
     const newGeometry = new (require('./primitives/geometry').Geometry)();
     newGeometry.createMesh(geometryIn, materialIn, options);
-    if (newGeometry.morph) {
+    if (newGeometry.getMorph()) {
       newGeometry.setName(groupName);
       if (region) region.addZincObject(newGeometry);
       newGeometry.setDuration(scene.getDuration());
@@ -570,6 +544,7 @@ exports.SceneLoader = function (sceneIn) {
     groupName,
     anatomicalId,
     renderOrder,
+    options,
     finishCallback
   ) => {
     return (geometry, materials) => {
@@ -577,10 +552,16 @@ exports.SceneLoader = function (sceneIn) {
       if (materials && materials[0]) {
         material = materials[0];
       }
-      const zincGeometry = addZincGeometry(region, geometry, colour, opacity, 
+      const zincGeometry = createZincGeometry(region, geometry, colour, opacity, 
         localTimeEnabled, localMorphColour, undefined, material, groupName, renderOrder);
       zincGeometry.anatomicalId = anatomicalId;
       zincGeometry.setRenderOrder(renderOrder);
+      console.log(options)
+      if (options.lod && options.lod.levels) {
+        for (const [key, value] of Object.entries(options.lod.levels)) {
+          zincGeometry.addLOD(primitivesLoader, key, value.URL, options.lod.preload);
+        }
+      }
       --this.toBeDownloaded;
       geometry.dispose();
       if (finishCallback != undefined && (typeof finishCallback == 'function'))
@@ -632,6 +613,15 @@ exports.SceneLoader = function (sceneIn) {
         newURL = item.Inline.URL;
         isInline = true;
       }
+      const lod = {};
+      if (item.LOD && item.LOD.Levels) {
+        lod.preload = item.LOD.Preload ? true : false;
+        lod.levels = {};
+        for (const [key, value] of Object.entries(item.LOD.Levels)) {
+          lod.levels[key] = {};
+          lod.levels[key]["URL"] = createNewURL(value.URL, referenceURL);
+        }
+      }
       let groupName = item.GroupName;
       if (groupName === undefined || groupName === "") {
         groupName = "_Unnamed";
@@ -642,6 +632,7 @@ exports.SceneLoader = function (sceneIn) {
         fileFormat: item.FileFormat,
         anatomicalId: item.AnatomicalId,
         compression: item.compression,
+        lod: lod,
         renderOrder: order
       };
       

package/src/shaders/textureSlide.js

@@ -28,16 +28,17 @@ const vs =
 out vec3 vUw;
 uniform float depth;
 uniform vec3 slide;
+uniform int direction;
 
 void main() {
 
   vec3 slidePos = position.xyz;
 
-  if (slide.x > 0.0)
+  if (direction == 1)
     slidePos = vec3(slide.x, position.x, position.y);
-  if (slide.y > 0.0)
+  if (direction == 2)
     slidePos = vec3(position.x, slide.y, position.y);
-  if (slide.z > 0.0)
+  if (direction == 3)
     slidePos = vec3(position.x, position.y, slide.z);
 
   gl_Position = projectionMatrix * modelViewMatrix * vec4( slidePos, 1.0 );
@@ -51,7 +52,8 @@ const getUniforms = function() {
   return {
     diffuse: { value: undefined },
     depth: { value: 1 },
-    slide: { value: new THREE.Vector3( 0, 0, 1 ) }
+    slide: { value: new THREE.Vector3( 0, 0, 1 ) },
+    direction: {value: 1},
   };
 }
 

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,40 @@ function resolveURL(url) {
 	return actualURL;
 }
 
+/*
+ * Calculate the bounding box of a mesh, values will be
+ * set for cachedBox, b1, v1 and v2 and they need to be
+ * defined. 
+ */
+function getBoundingBox(mesh, cachedBox, b1, v1, v2) {
+  let influences = mesh.morphTargetInfluences;
+  let attributes = undefined;
+  if (mesh.geometry)
+    attributes = mesh.geometry.morphAttributes;
+  let found = false;
+  if (influences && attributes && attributes.position) {
+    v1.set(0.0, 0.0, 0.0);
+    v2.set(0.0, 0.0, 0.0);
+    for (let i = 0; i < influences.length; i++) {
+      if (influences[i] > 0) {
+        found = true;
+        b1.setFromArray(attributes.position[i].array);
+        v1.add(b1.min.multiplyScalar(influences[i]));
+        v2.add(b1.max.multiplyScalar(influences[i]));
+      }
+    }
+    if (found)
+    cachedBox.set(v1, v2);
+  }
+  if (!found) {
+    cachedBox.setFromBufferAttribute(
+      mesh.geometry.attributes.position);
+  }
+  mesh.updateWorldMatrix();
+  cachedBox.applyMatrix4(mesh.matrixWorld);
+}
+
+
 //Convenient function
 function loadExternalFile(url, data, callback, errorCallback) {
     // Set up an asynchronous request
@@ -81,218 +116,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) {
@@ -314,7 +395,7 @@ function PhongToToon(materialIn) {
 	return materialIn;
 }
 
-
+exports.getBoundingBox = getBoundingBox;
 exports.resolveURL = resolveURL;
 exports.loadExternalFile = loadExternalFile;
 exports.loadExternalFiles = loadExternalFiles;

package/src/workers/geometryCSG.worker.js

@@ -9,10 +9,10 @@ module.exports = function (self) {
 		var JSONParser = new JSONLoader();
 		var geometry = JSONParser.parse(object);
 		var material = new THREE.MeshPhongMaterial();
-        var mesh = new THREE.Mesh(geometry.geometry, material);
-        var host = new Geometry();
-        host.morph = mesh;
-        return host;
+    var mesh = new THREE.Mesh(geometry.geometry, material);
+    var host = new Geometry();
+    host.setMorph(mesh);
+    return host;
 	}
 
 	var initialise = function(object) {