Updated API

@peteruithoven @mith

I think this is a somewhat nicer API for the slicer. I completely
removed the Slicer class and instead added two function: sliceGeometry
and sliceMesh

src/Slicer.js

@@ -2,70 +2,73 @@ import * as THREE from 'three';
 import slice from './sliceActions/slice.js';
 import SlicerWorker from './slicerWorker.js!worker';
 
-export default class {
-  setMesh(mesh) {
-    mesh.updateMatrix();
-
-    return this.setGeometry(mesh.geometry, mesh.matrix);
+export function sliceMesh(settings, mesh, sync = false, onProgress) {
+  if (typeof mesh === 'undefined' || !mesh.isMesh) {
+    throw new Error('Provide mesh is not intance of THREE.Mesh');
   }
-  setGeometry(geometry, matrix) {
-    if (geometry.isBufferGeometry) {
-      geometry = new THREE.Geometry().fromBufferGeometry(geometry);
-    } else if (geometry.isGeometry) {
-      geometry = geometry.clone();
-    } else {
-      throw new Error('Geometry is not an instance of BufferGeometry or Geometry');
-    }
 
-    if (typeof matrix !== 'undefined') {
-      geometry.applyMatrix(matrix);
-    }
+  mesh.updateMatrix();
+  const { geometry, matrix } = mesh;
+  return sliceGeometry(settings, geometry, matrix, sync, onProgress);
+}
 
-    this.geometry = geometry;
-
-    return this;
+export function sliceGeometry(settings, geometry, matrix, sync = false, onProgress) {
+  if (typeof geometry === 'undefined') {
+    throw new Error('Missing required geometry argument');
+  } else if (geometry.isBufferGeometry) {
+    geometry = new THREE.Geometry().fromBufferGeometry(geometry);
+  } else if (geometry.isGeometry) {
+    geometry = geometry.clone();
+  } else {
+    throw new Error('Geometry is not an instance of BufferGeometry or Geometry');
   }
-  sliceSync(settings, onProgress) {
-    if (typeof this.geometry === 'undefined') {
-      throw new Error('Geometry is not set, use Slicer.setGeometry or Slicer.setMesh first');
-    }
 
-    return slice(this.geometry, settings, onProgress);
+  if (matrix) {
+    geometry.applyMatrix(matrix);
   }
-  slice(settings, onProgress) {
-    if (typeof this.geometry === 'undefined') {
-      throw new Error('Geometry is not set, use Slicer.setGeometry or Slicer.setMesh first');
-    }
 
-    return new Promise((resolve, reject) => {
-      // create the slicer worker
-      const slicerWorker = new SlicerWorker();
-      slicerWorker.onerror = reject;
-
-      // listen to messages send from worker
-      slicerWorker.addEventListener('message', (event) => {
-        const { message, data } = event.data;
-        switch (message) {
-          case 'SLICE': {
-            slicerWorker.terminate();
-            resolve(data.gcode);
-            break;
-          }
-          case 'PROGRESS': {
-            if (typeof onProgress !== 'undefined') {
-              onProgress(data);
-            }
-            break;
-          }
-        }
-      });
-
-      // send geometry and settings to worker to start the slicing progress
-      const geometry = this.geometry.toJSON();
-      slicerWorker.postMessage({
-        message: 'SLICE',
-        data: { geometry, settings }
-      });
-    });
+  if (sync) {
+    return sliceSync(settings, geometry, onProgress);
+  } else {
+    return sliceAsync(settings, geometry, onProgress);
   }
 }
+
+function sliceSync(settings, geometry, onProgress) {
+  return slice(settings, geometry, onProgress);
+}
+
+function sliceAsync(settings, geometry, onProgress) {
+  return new Promise((resolve, reject) => {
+    // create the slicer worker
+    const slicerWorker = new SlicerWorker();
+    slicerWorker.onerror = reject;
+
+    // listen to messages send from worker
+    slicerWorker.addEventListener('message', (event) => {
+      const { message, data } = event.data;
+      switch (message) {
+        case 'SLICE': {
+          slicerWorker.terminate();
+          resolve(data.gcode);
+          break;
+        }
+        case 'PROGRESS': {
+          if (typeof onProgress !== 'undefined') {
+            onProgress(data);
+          }
+          break;
+        }
+      }
+    });
+
+    // send geometry and settings to worker to start the slicing progress
+    slicerWorker.postMessage({
+      message: 'SLICE',
+      data: {
+        settings,
+        geometry: geometry.toJSON()
+      }
+    });
+  });
+}

src/index.js

@@ -1,4 +1,4 @@
-import Slicer from './Slicer.js';
+import { sliceGeometry, sliceMesh } from './slicer.js';
 import baseSettings from './settings/default.yml!text';
 import printerSettings from './settings/printer.yml!text';
 import materialSettings from './settings/material.yml!text';
@@ -13,6 +13,7 @@ const defaultSettings = {
 };
 
 export {
-  Slicer,
+  sliceGeometry,
+  sliceMesh,
   defaultSettings
 };

src/sliceActions/slice.js

@@ -13,12 +13,20 @@ import detectOpenClosed from './detectOpenClosed.js';
 import applyPrecision from './applyPrecision.js';
 import removePrecision from './removePrecision.js';
 
-export default function(geometry, settings, onProgress) {
+export default function(settings, geometry, onProgress) {
   const totalStages = 12;
   let current = -1;
   const updateProgress = (action) => {
     current ++;
-    if (onProgress) onProgress({ done: current, total: totalStages, action });
+    if (typeof onProgress !== 'undefined') {
+      onProgress({
+        progress: {
+          done: current,
+          total: totalStages,
+          action
+        }
+      });
+    }
   };
 
   geometry.computeFaceNormals();

src/slicerWorker.js

@@ -6,7 +6,7 @@ const loader = new THREE.JSONLoader();
 const onProgress = progress => {
   self.postMessage({
     message: 'PROGRESS',
-    data: { progress }
+    data: progress
   });
 }
 
@@ -14,11 +14,10 @@ self.addEventListener('message', (event) => {
   const { message, data } = event.data;
   switch (message) {
     case 'SLICE': {
-      const { geometry: JSONGeometry, settings } = data;
-
+      const { settings, geometry: JSONGeometry } = data;
       const { geometry } = loader.parse(JSONGeometry.data);
 
-      const gcode = slice(geometry, settings, onProgress);
+      const gcode = slice(settings, geometry, onProgress);
 
       self.postMessage({
         message: 'SLICE',