zincjs 3.0.0 → 3.0.1

package/src/geometryCSG.js

@@ -7,142 +7,138 @@ import { GeometryCSGInternal } from './workers/geometryCSGInternal';
 const ThreeBSP = ThreeBSPWrapper(THREE);
 const JSONLoader = THREE.BufferGeometryLoader;
 
-
 const GeometryCSG = function (hostIn) {
   //ZincGeoemtry of the main geometry
   let host = undefined;
-  if (hostIn && hostIn.isGeometry)
-	host = hostIn;
+  if (hostIn && hostIn.isGeometry) host = hostIn;
   let core = undefined;
   let worker = undefined;
   let onProgress = false;
   let myResolve = undefined;
 
-  var createGeometryFromJSON = json => {
-	  const material = host.getMorph().material.clone();
-	  material.morphTargets = false;
-	  const newGeometry = new Geometry();
-		const JSONParser = new JSONLoader();
-		const geometry = JSONParser.parse(json);
+  var createGeometryFromJSON = (json) => {
+    const material = host.getMorph().material.clone();
+    material.morphTargets = false;
+    const newGeometry = new Geometry();
+    const JSONParser = new JSONLoader();
+    const geometry = JSONParser.parse(json);
     const mesh = new THREE.Mesh(geometry.geometry, material);
-	  newGeometry.geometry = mesh.geometry;
+    newGeometry.geometry = mesh.geometry;
     mesh.userData = newGeometry;
-	  newGeometry.setMorph(mesh);
-	  return newGeometry;
-  }
-
-  var workerEventHandler = ev => {
-	  switch (ev.data.action) {
-	  	case 'message':
-	        console.log(ev.data.message);
-	        break;
-	  	case 'result':
-	    	const csg = new GeometryCSG(createGeometryFromJSON(ev.data.object));
-	    	if (myResolve)
-	    		myResolve(csg);
-	    	myResolve = undefined;
-	    	onProgress = false;
-	        break;
-	  	default:
-	    	throw 'Cannot handle specified action.';
+    newGeometry.setMorph(mesh);
+    return newGeometry;
+  };
+
+  var workerEventHandler = (ev) => {
+    switch (ev.data.action) {
+      case 'message':
+        console.log(ev.data.message);
+        break;
+      case 'result':
+        const csg = new GeometryCSG(createGeometryFromJSON(ev.data.object));
+        if (myResolve) myResolve(csg);
+        myResolve = undefined;
+        onProgress = false;
+        break;
+      default:
+        throw 'Cannot handle specified action.';
     }
-  }
-
-  var initialise = hostIn => {
-	  if (work !== undefined) {
-		  worker = new GeometryWorker();
-	  }
-	  if (!worker) {
-	    core = new GeometryCSGInternal(hostIn);
-	  } else {
-		if (hostIn && hostIn.isGeometry) {
-		  let mesh = hostIn.getMorph();
-		  let json = mesh.geometry.clone().applyMatrix(mesh.matrix).toJSON();
-		  worker.addEventListener('message', function (ev) {
-			  workerEventHandler(ev);
-		  });
-		  worker.postMessage({action: "initialise", object: json});
-		}
-	  }
-  }
+  };
+
+  var initialise = (hostIn) => {
+    if (work !== undefined) {
+      worker = new GeometryWorker();
+    }
+    if (!worker) {
+      core = new GeometryCSGInternal(hostIn);
+    } else {
+      if (hostIn && hostIn.isGeometry) {
+        let mesh = hostIn.getMorph();
+        let json = mesh.geometry.clone().applyMatrix(mesh.matrix).toJSON();
+        worker.addEventListener('message', function (ev) {
+          workerEventHandler(ev);
+        });
+        worker.postMessage({ action: 'initialise', object: json });
+      }
+    }
+  };
 
   this.getHostGeometry = () => {
-	const tempCSG = new ThreeBSP(host.getMorph());
+    const tempCSG = new ThreeBSP(host.getMorph());
     return new createZincGeometry(tempCSG);
-  }
+  };
 
   this.getGeometry = () => host;
 
-  const createZincGeometry = csgMesh => {
-		const material = host.getMorph().material.clone();
-		material.morphTargets = false;
-		const newMesh = csgMesh.toMesh(material);
-	    const newGeometry = new Geometry();
-	    newGeometry.geometry = newMesh.geometry;
-	    newMesh.userData = newGeometry;
-	    newGeometry.setMorph(newMesh);
-	    return newGeometry;
-  }
-
-  this.setCSG = CSG => {
-	  core.setCSG(CSG);
-  }
+  const createZincGeometry = (csgMesh) => {
+    const material = host.getMorph().material.clone();
+    material.morphTargets = false;
+    const newMesh = csgMesh.toMesh(material);
+    const newGeometry = new Geometry();
+    newGeometry.geometry = newMesh.geometry;
+    newMesh.userData = newGeometry;
+    newGeometry.setMorph(newMesh);
+    return newGeometry;
+  };
+
+  this.setCSG = (CSG) => {
+    core.setCSG(CSG);
+  };
 
   const sendToWork = (guestGeometry, action, resolve, reject) => {
-	  if (!onProgress) {
-		  let mesh = guestGeometry.getMorph();
-		  const json = mesh.geometry.clone().applyMatrix(mesh.matrix).toJSON();
-		  myResolve = resolve;
-		  onProgress = true;
-		  worker.postMessage({action: action, object: json});
-	  } else {
-		  reject("On progress");
-	  }
-  }
-
-  this.intersect = guestGeometry => {
-	  return new Promise((resolve, reject) => {
-		  if (worker) {
-			  sendToWork(guestGeometry, "intersect", resolve, reject);
-		  } else {
-			  const result = core.intersect(guestGeometry);
-			  const newCSG = new GeometryCSG(createZincGeometry(result));
-			  newCSG.setCSG(result);
-			  resolve(newCSG);
-		  }
-	  });
-	};
-
-  this.subtract = guestGeometry => {
-	  return new Promise((resolve, reject) => {
-		  if (worker) {
-			  sendToWork(guestGeometry, "intersect", resolve, reject);
-		  } else {
-			  const result = core.subtract(guestGeometry);
-			  const newCSG = new GeometryCSG(createZincGeometry(result));
-			  newCSG.setCSG(result);
-			  resolve(newCSG);
-		  }
-	  });
-  }
-
-  this.union = guestGeometry => {
-	  return new Promise((resolve, reject) => {
-		  if (worker) {
-			  sendToWork(guestGeometry, "intersect", resolve, reject);
-		  } else {
-			  const result = core.union(guestGeometry);
-			  const newCSG = new GeometryCSG(createZincGeometry(result));
-			  newCSG.setCSG(result);
-			  resolve(newCSG);
-		  }
-	  });
-  }
+    if (!onProgress) {
+      let mesh = guestGeometry.getMorph();
+      const json = mesh.geometry.clone().applyMatrix(mesh.matrix).toJSON();
+      myResolve = resolve;
+      onProgress = true;
+      worker.postMessage({ action: action, object: json });
+    } else {
+      reject('On progress');
+    }
+  };
+
+  this.intersect = (guestGeometry) => {
+    return new Promise((resolve, reject) => {
+      if (worker) {
+        sendToWork(guestGeometry, 'intersect', resolve, reject);
+      } else {
+        const result = core.intersect(guestGeometry);
+        const newCSG = new GeometryCSG(createZincGeometry(result));
+        newCSG.setCSG(result);
+        resolve(newCSG);
+      }
+    });
+  };
+
+  this.subtract = (guestGeometry) => {
+    return new Promise((resolve, reject) => {
+      if (worker) {
+        sendToWork(guestGeometry, 'intersect', resolve, reject);
+      } else {
+        const result = core.subtract(guestGeometry);
+        const newCSG = new GeometryCSG(createZincGeometry(result));
+        newCSG.setCSG(result);
+        resolve(newCSG);
+      }
+    });
+  };
+
+  this.union = (guestGeometry) => {
+    return new Promise((resolve, reject) => {
+      if (worker) {
+        sendToWork(guestGeometry, 'intersect', resolve, reject);
+      } else {
+        const result = core.union(guestGeometry);
+        const newCSG = new GeometryCSG(createZincGeometry(result));
+        newCSG.setCSG(result);
+        resolve(newCSG);
+      }
+    });
+  };
 
   this.terminateWorker = () => {
-	  if (worker)
-		  worker.terminate();
-  }
+    if (worker) worker.terminate();
+  };
 
   initialise(hostIn);
 };

package/src/glyphsetCSG.js

@@ -14,73 +14,69 @@ const ThreeBSP = ThreeBSPWrapper(THREE);
  */
 const GlyphsetCSG = function (hostIn) {
   let host = undefined;
-  if (hostIn && hostIn.isGlyphset)
-	  host = hostIn;
+  if (hostIn && hostIn.isGlyphset) host = hostIn;
   const hostCSGs = new Array();
   const currentIntersect = undefined;
 
-  this.setGlyphset = hostIn => {
-	  if (hostIn && hostIn.isGlyphset)
-		  host = hostIn;
-	  hostCSG = undefined;
-  }
+  this.setGlyphset = (hostIn) => {
+    if (hostIn && hostIn.isGlyphset) host = hostIn;
+    hostCSG = undefined;
+  };
 
   this.getGlyphset = () => {
-	  return host;
-  }
+    return host;
+  };
 
   const prepareCSGForGlyphs = () => {
-	  return glyph => {
-		  const mesh = glyph.getMesh();
-		  const label = glyph.getLabel();
-		  if (mesh) {
-			  const csg = new ThreeBSP(mesh.geometry.clone().applyMatrix(mesh.matrix));
-			  const store = [];
-			  store.csg = csg;
-			  store.label = label;
-			  if (mesh.material)
-				  store.material = mesh.material.clone();
-			  hostCSGs.push(store);
-		  }
-	  };
+    return (glyph) => {
+      const mesh = glyph.getMesh();
+      const label = glyph.getLabel();
+      if (mesh) {
+        const csg = new ThreeBSP(mesh.geometry.clone().applyMatrix(mesh.matrix));
+        const store = [];
+        store.csg = csg;
+        store.label = label;
+        if (mesh.material) store.material = mesh.material.clone();
+        hostCSGs.push(store);
+      }
+    };
   };
 
-  const prepareCSG = guestGeometry => {
-	  if (host && guestGeometry && guestGeometry.getMorph()) {
-	      if (hostCSGs.length == 0) {
-	    	  host.forEachGlyph(prepareCSGForGlyphs());
-	      }
-	     const guestCSG = new ThreeBSP(guestGeometry.getMorph());
-	     return guestCSG;
-	  }
-	  return undefined;
+  const prepareCSG = (guestGeometry) => {
+    if (host && guestGeometry && guestGeometry.getMorph()) {
+      if (hostCSGs.length == 0) {
+        host.forEachGlyph(prepareCSGForGlyphs());
+      }
+      const guestCSG = new ThreeBSP(guestGeometry.getMorph());
+      return guestCSG;
+    }
+    return undefined;
   };
 
-  this.intersect = guestGeometry => {
-	  const guestCSG = prepareCSG(guestGeometry);
-	  if ((hostCSGs.length > 0) && guestCSG) {
-		const glyphset = new Glyphset();
-		for (let i = 0; i < hostCSGs.length; i++) {
-			const hostCSG = hostCSGs[i];
-		    const intersect = hostCSG.csg.intersect(guestCSG);
-		    const mesh = intersect.toMesh();
-		    if (mesh && mesh.geometry && (mesh.geometry.vertices.length > 0)) {
-		    	if (hostCSG.material) {
-		    		mesh.material = hostCSG.material;
-		    		mesh.material.side = THREE.DoubleSide;
-		    		mesh.material.clippingPlanes = null;
-		    	}
-			    const glyph = glyphset.addMeshAsGlyph(mesh, i+1);
-			    glyph.setLabel(hostCSG.label);
-		    }
-		}
-	    const newCSG = new GlyphsetCSG(glyphset);
-	    return newCSG;
-	  }
-
-	  return undefined;
-  }
+  this.intersect = (guestGeometry) => {
+    const guestCSG = prepareCSG(guestGeometry);
+    if (hostCSGs.length > 0 && guestCSG) {
+      const glyphset = new Glyphset();
+      for (let i = 0; i < hostCSGs.length; i++) {
+        const hostCSG = hostCSGs[i];
+        const intersect = hostCSG.csg.intersect(guestCSG);
+        const mesh = intersect.toMesh();
+        if (mesh && mesh.geometry && mesh.geometry.vertices.length > 0) {
+          if (hostCSG.material) {
+            mesh.material = hostCSG.material;
+            mesh.material.side = THREE.DoubleSide;
+            mesh.material.clippingPlanes = null;
+          }
+          const glyph = glyphset.addMeshAsGlyph(mesh, i + 1);
+          glyph.setLabel(hostCSG.label);
+        }
+      }
+      const newCSG = new GlyphsetCSG(glyphset);
+      return newCSG;
+    }
 
+    return undefined;
+  };
 };
 
 export { GlyphsetCSG };

package/src/loaders/GLTFToZincJSLoader.js

@@ -5,7 +5,6 @@ import { Pointset } from '../primitives/pointset';
 import { applyMorphColorNode } from '../tsl/morphColorMaterial';
 
 const GLTFToZincJSLoader = function () {
-
   const _this = this;
 
   /*
@@ -40,7 +39,7 @@ const GLTFToZincJSLoader = function () {
       });
     }
     geometry.morphTargetsRelative = false;
-  }
+  };
 
   /*
    * Zinc renders colour morphs with its own colorNode (see geometry.js and
@@ -54,32 +53,32 @@ const GLTFToZincJSLoader = function () {
       material.vertexColors = false;
       return applyMorphColorNode(material);
     };
-    object.material = Array.isArray(object.material) ?
-      object.material.map(setup) : setup(object.material);
-  }
+    object.material = Array.isArray(object.material)
+      ? object.material.map(setup)
+      : setup(object.material);
+  };
 
   this.parseGLTFObjects = (object, region, depth, finishCallback) => {
     let childRegion = region;
     if (depth !== 0) {
-      if (object.type === "Object3D") {
-        if (object.name !== "") {
-          if (region)
-            childRegion = region.findOrCreateChildFromPath(object.name);
-            if (childRegion) {
-              const group = childRegion.getGroup();
-              group.position.copy(object.position);
-              group.rotation.copy(object.rotation);
-              group.quaternion.copy(object.quaternion);
-              group.matrixAutoUpdate = true;
-            }
+      if (object.type === 'Object3D') {
+        if (object.name !== '') {
+          if (region) childRegion = region.findOrCreateChildFromPath(object.name);
+          if (childRegion) {
+            const group = childRegion.getGroup();
+            group.position.copy(object.position);
+            group.rotation.copy(object.rotation);
+            group.quaternion.copy(object.quaternion);
+            group.matrixAutoUpdate = true;
+          }
         }
       } else {
         let zincGeometry = undefined;
-        if (object.type === "Mesh") {
+        if (object.type === 'Mesh') {
           zincGeometry = new Geometry();
-        } else if (object.type === "LineSegments") {
+        } else if (object.type === 'LineSegments') {
           zincGeometry = new Lines();
-        } else if (object.type === "Points") {
+        } else if (object.type === 'Points') {
           zincGeometry = new Pointset();
         }
         if (zincGeometry) {
@@ -91,31 +90,30 @@ const GLTFToZincJSLoader = function () {
             localMorphColour = object.geometry.morphAttributes.color ? true : false;
           }
           const mesh = object.clone();
-          if (localMorphColour && !zincGeometry.isPointset)
-            applyMorphColourMaterial(mesh);
+          if (localMorphColour && !zincGeometry.isPointset) applyMorphColourMaterial(mesh);
           zincGeometry.setMesh(mesh, localTimeEnabled, localMorphColour);
           const morph = zincGeometry.getMorph();
           zincGeometry.groupName = morph.name;
           morph.matrixAutoUpdate = true;
           region.addZincObject(zincGeometry);
-          if (finishCallback != undefined && (typeof finishCallback == 'function'))
+          if (finishCallback != undefined && typeof finishCallback == 'function')
             finishCallback(zincGeometry);
         }
       }
     }
     depth++;
-    object.children.forEach( child => {
+    object.children.forEach((child) => {
       _this.parseGLTFObjects(child, childRegion, depth, finishCallback);
     });
-  }
+  };
 
-  this.setCamera = scene => {
+  this.setCamera = (scene) => {
     scene.viewAll();
     const cameraControls = scene.getZincCameraControls();
     const viewport = cameraControls.getCurrentViewport();
     cameraControls.addViewport('default', viewport);
     cameraControls.setDefaultViewport('default');
-  }
+  };
 
   /**
    * Load GLTF into this scene object.
@@ -127,19 +125,19 @@ const GLTFToZincJSLoader = function () {
    * load has been cancelled, the loaded content will be discarded.
    */
   this.load = (scene, region, url, finishCallback, allCompletedCallback, options, isCancelled) => {
-    const path = url.substring(0, url.lastIndexOf("/") + 1);
-    const filename = url.substring(url.lastIndexOf("/") + 1, url.length);
+    const path = url.substring(0, url.lastIndexOf('/') + 1);
+    const filename = url.substring(url.lastIndexOf('/') + 1, url.length);
     const loader = new GLTFLoader().setPath(path);
 
-    loader.load( filename, function ( gltf ) {
+    loader.load(filename, function (gltf) {
       if (isCancelled && isCancelled()) return;
-      console.log(gltf)
+      console.log(gltf);
       _this.parseGLTFObjects(gltf.scene, region, 0, finishCallback);
       _this.setCamera(scene);
-      if (allCompletedCallback != undefined && (typeof allCompletedCallback == 'function'))
+      if (allCompletedCallback != undefined && typeof allCompletedCallback == 'function')
         allCompletedCallback();
     });
-  }
-}
+  };
+};
 
 export { GLTFToZincJSLoader };