zincjs 1.0.13 → 1.0.15

package/src/geometryCSG.js

@@ -0,0 +1,148 @@
+const THREE = require('three');
+const ThreeBSP = require('./three-js-csg')(THREE);
+const Geometry = require('./primitives/geometry').Geometry;
+const work = require('webworkify-webpack');
+const Promise = require('promise-polyfill').default;
+//const work = undefined;
+const JSONLoader = THREE.BufferGeometryLoader;
+
+const GeometryCSG = function (hostIn) {
+  //ZincGeoemtry of the main geometry
+  let host = undefined;
+  if (hostIn && hostIn.isGeometry)
+	host = hostIn;
+  let core = undefined;
+  let worker = undefined;
+  let onProgress = false;
+  let myResolve = undefined;
+  
+  var createGeometryFromJSON = json => {
+	  	const material = host.morph.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.morph = mesh;
+	    newGeometry.morph.userData = newGeometry;
+	    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 = work(require.resolve('./workers/geometryCSG.worker.js'));
+	  }
+	  if (!worker) {
+	    core = new (require('./workers/geometryCSGInternal').GeometryCSGInternal)(hostIn);
+	  } else {
+		if (hostIn && hostIn.isGeometry) {
+		  let mesh = hostIn.morph;
+		  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.morph);
+    return new createZincGeometry(tempCSG);
+  }
+  
+  this.getGeometry = () => host;
+  
+  const createZincGeometry = csgMesh => {
+		const material = host.morph.material.clone();
+		material.morphTargets = false;
+		const newMesh = csgMesh.toMesh(material);
+	    const newGeometry = new Geometry();
+	    newGeometry.geometry = newMesh.geometry;
+	    newGeometry.morph = newMesh;
+	    newGeometry.morph.userData = newGeometry;
+	    return newGeometry;
+  }
+  
+  this.setCSG = CSG => {
+	  core.setCSG(CSG);
+  } 
+  
+  const sendToWork = (guestGeometry, action, resolve, reject) => {
+	  if (!onProgress) {
+		  let mesh = guestGeometry.morph;
+		  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();
+  }
+  
+  initialise(hostIn);
+};
+
+exports.GeometryCSG = GeometryCSG;

package/src/glyphsetCSG.js

@@ -0,0 +1,84 @@
+const THREE = require('three');
+const ThreeBSP = require('./three-js-csg')(THREE);
+const Glyphset = require('./primitives/glyphset').Glyphset;
+
+/**
+ * Provides an object which takes in a glyphset, convert it into a CSG and further
+ * action such as intersect with another geometry may be performed.
+ * 
+ * @class
+ * @author Alan Wu
+ * @return {GlyphsetCSG}
+ */
+const GlyphsetCSG = function (hostIn) {
+  let host = undefined;
+  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.getGlyphset = () => {
+	  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);
+		  }
+	  };
+  };
+  
+  const prepareCSG = guestGeometry => {
+	  if (host && guestGeometry && guestGeometry.morph) {
+	      if (hostCSGs.length == 0) {
+	    	  host.forEachGlyph(prepareCSGForGlyphs());
+	      }
+	     const guestCSG = new ThreeBSP(guestGeometry.morph);
+	     return guestCSG;
+	  }
+	  return undefined;
+  };
+  
+  this.intersect = guestGeometry => {
+	  const guestCSG = prepareCSG(guestGeometry);
+	  if ((hostCSGs.length > 0) && guestCSG) {
+		const glyphset = new (require('./primitives/glyphset').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;
+  }
+  
+};
+
+exports.GlyphsetCSG = GlyphsetCSG;

package/src/loaders/GLTFToZincJSLoader.js

@@ -0,0 +1,85 @@
+const THREE = require('three');
+
+const GLTFLoader = require('three/examples/jsm/loaders/GLTFLoader').GLTFLoader;
+
+const GLTFToZincJSLoader = function () {
+
+  const _this = this;
+
+  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;
+            }
+        }
+      } else {
+        let zincGeometry = undefined;
+        if (object.type === "Mesh") {
+          zincGeometry = new (require('../primitives/geometry').Geometry)();
+        } else if (object.type === "LineSegments") {
+          zincGeometry = new (require('../primitives/lines').Lines)();
+        } else if (object.type === "Points") {
+          zincGeometry = new (require('../primitives/pointset').Pointset)();
+        }
+        if (zincGeometry) {
+          let localTimeEnabled = false;
+          let localMorphColour = false;
+          if (object.geometry && object.geometry.morphAttributes) {
+            localTimeEnabled = object.geometry.morphAttributes.position ? true : false;
+            localMorphColour = object.geometry.morphAttributes.color ? true : false;
+          }
+          zincGeometry.setMesh(object.clone(), localTimeEnabled, localMorphColour);
+          region.addZincObject(zincGeometry);
+          zincGeometry.groupName = zincGeometry.morph.name;
+          zincGeometry.morph.matrixAutoUpdate = true;
+          if (finishCallback != undefined && (typeof finishCallback == 'function'))
+            finishCallback(zincGeometry);
+        }
+      }
+    }
+    depth++;
+    object.children.forEach( child => {
+      _this.parseGLTFObjects(child, childRegion, depth, finishCallback);
+    });
+  }
+
+  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.
+   * 
+   * @param {String} url - URL to the GLTF file
+   * @param {Function} finishCallback - Callback function which will be called
+   * once the glyphset is succssfully load in.
+   */
+  this.load = (scene, region, url, finishCallback, allCompletedCallback, options) => {
+    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 ) {
+      console.log(gltf)
+      _this.parseGLTFObjects(gltf.scene, region, 0, finishCallback);
+      _this.setCamera(scene);
+      if (allCompletedCallback != undefined && (typeof allCompletedCallback == 'function'))
+        allCompletedCallback();
+    });
+  }
+}
+
+exports.GLTFToZincJSLoader = GLTFToZincJSLoader;