2018-01-18 12:06:14 +01:00
|
|
|
import * as THREE from 'three';
|
2017-12-19 12:38:58 +01:00
|
|
|
import slice from './sliceActions/slice.js';
|
2017-07-20 11:54:49 +02:00
|
|
|
import SlicerWorker from './slicer.worker.js';
|
2017-12-19 12:38:58 +01:00
|
|
|
|
|
|
|
export function sliceMesh(settings, mesh, sync = false, constructLinePreview = false, onProgress) {
|
|
|
|
if (!mesh || !mesh.isMesh) {
|
|
|
|
throw new Error('Provided mesh is not intance of THREE.Mesh');
|
|
|
|
}
|
|
|
|
|
|
|
|
mesh.updateMatrix();
|
|
|
|
const { geometry, matrix, material } = mesh;
|
|
|
|
return sliceGeometry(settings, geometry, material, matrix, sync, constructLinePreview, onProgress);
|
|
|
|
}
|
|
|
|
|
|
|
|
export function sliceGeometry(settings, geometry, materials, matrix, sync = false, constructLinePreview = false, onProgress) {
|
|
|
|
if (!geometry) {
|
|
|
|
throw new Error('Missing required geometry argument');
|
|
|
|
} else if (geometry.isBufferGeometry) {
|
2018-01-18 12:06:14 +01:00
|
|
|
geometry = new THREE.Geometry().fromBufferGeometry(geometry);
|
2017-12-19 12:38:58 +01:00
|
|
|
} else if (geometry.isGeometry) {
|
|
|
|
geometry = geometry.clone();
|
|
|
|
} else {
|
|
|
|
throw new Error('Geometry is not an instance of BufferGeometry or Geometry');
|
|
|
|
}
|
|
|
|
|
2018-02-12 00:10:44 +01:00
|
|
|
if (matrix && matrix.isMatrix4) geometry.applyMatrix(matrix);
|
|
|
|
geometry.computeFaceNormals();
|
2017-12-19 12:38:58 +01:00
|
|
|
|
2018-02-12 00:10:44 +01:00
|
|
|
const vertices = geometry.vertices.reduce((array, { x, y, z }, i) => {
|
|
|
|
const i3 = i * 3;
|
|
|
|
array[i3] = x;
|
|
|
|
array[i3 + 1] = y;
|
|
|
|
array[i3 + 2] = z;
|
|
|
|
return array;
|
|
|
|
}, new Float32Array(geometry.vertices.length * 3));
|
|
|
|
const faces = geometry.faces.reduce((array, { a, b, c }, i) => {
|
|
|
|
const i3 = i * 3;
|
|
|
|
array[i3] = a;
|
|
|
|
array[i3 + 1] = b;
|
|
|
|
array[i3 + 2] = c;
|
|
|
|
return array;
|
|
|
|
}, new Uint32Array(geometry.faces.length * 3));
|
|
|
|
const faceNormals = geometry.faces.reduce((array, { normal: { x, y, z } }, i) => {
|
|
|
|
const i3 = i * 3;
|
|
|
|
array[i3] = x;
|
|
|
|
array[i3 + 1] = y;
|
|
|
|
array[i3 + 2] = z;
|
|
|
|
return array;
|
|
|
|
}, new Float32Array(geometry.faces.length * 3));
|
|
|
|
const objectIndexes = geometry.faces.reduce((array, { materialIndex }, i) => {
|
|
|
|
array[i] = materialIndex;
|
|
|
|
return array;
|
|
|
|
}, new Uint8Array(geometry.faces.length));
|
|
|
|
|
|
|
|
if (faces.length === 0) throw new Error('Geometry does not contain any data');
|
|
|
|
|
|
|
|
geometry = { vertices, faces, objectIndexes, faceNormals };
|
2017-12-19 12:38:58 +01:00
|
|
|
|
|
|
|
const openObjectIndexes = materials instanceof Array ? materials.map(({ side }) => {
|
|
|
|
switch (side) {
|
2018-01-18 12:06:14 +01:00
|
|
|
case THREE.FrontSide:
|
2017-12-19 12:38:58 +01:00
|
|
|
return false;
|
2018-01-18 12:06:14 +01:00
|
|
|
case THREE.DoubleSide:
|
2017-12-19 12:38:58 +01:00
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}) : [false];
|
2015-07-26 15:32:10 +02:00
|
|
|
|
2017-07-20 10:29:33 +02:00
|
|
|
if (sync) {
|
2017-12-19 12:38:58 +01:00
|
|
|
return sliceSync(settings, geometry, openObjectIndexes, constructLinePreview, onProgress);
|
2017-07-20 10:29:33 +02:00
|
|
|
} else {
|
2017-12-19 12:38:58 +01:00
|
|
|
return sliceAsync(settings, geometry, openObjectIndexes, constructLinePreview, onProgress);
|
2017-05-13 14:48:48 +02:00
|
|
|
}
|
2017-07-20 10:29:33 +02:00
|
|
|
}
|
|
|
|
|
2017-12-19 12:38:58 +01:00
|
|
|
function sliceSync(settings, geometry, openObjectIndexes, constructLinePreview, onProgress) {
|
|
|
|
return slice(settings, geometry, openObjectIndexes, constructLinePreview, onProgress);
|
2017-07-20 10:29:33 +02:00
|
|
|
}
|
2017-05-13 14:48:48 +02:00
|
|
|
|
2017-12-19 12:38:58 +01:00
|
|
|
function sliceAsync(settings, geometry, openObjectIndexes, constructLinePreview, onProgress) {
|
2017-07-20 10:29:33 +02:00
|
|
|
return new Promise((resolve, reject) => {
|
|
|
|
// create the slicer worker
|
|
|
|
const slicerWorker = new SlicerWorker();
|
2017-07-24 15:40:54 +02:00
|
|
|
|
2018-01-17 15:27:42 +01:00
|
|
|
slicerWorker.addEventListener('error', event => {
|
2017-07-24 15:40:54 +02:00
|
|
|
slicerWorker.terminate();
|
2018-01-17 15:27:42 +01:00
|
|
|
reject(event);
|
|
|
|
});
|
2017-05-13 14:48:48 +02:00
|
|
|
|
2017-07-20 10:29:33 +02:00
|
|
|
// listen to messages send from worker
|
|
|
|
slicerWorker.addEventListener('message', (event) => {
|
|
|
|
const { message, data } = event.data;
|
|
|
|
switch (message) {
|
|
|
|
case 'SLICE': {
|
|
|
|
slicerWorker.terminate();
|
2017-11-12 11:53:45 +01:00
|
|
|
|
2018-02-11 23:28:25 +01:00
|
|
|
// if (data.gcode.linePreview) {
|
|
|
|
// const geometry = new THREE.BufferGeometry();
|
|
|
|
//
|
|
|
|
// const { position, color } = data.gcode.linePreview;
|
|
|
|
// geometry.addAttribute('position', new THREE.BufferAttribute(new Float32Array(position), 3));
|
|
|
|
// geometry.addAttribute('color', new THREE.BufferAttribute(new Float32Array(color), 3));
|
|
|
|
//
|
|
|
|
// const material = new THREE.LineBasicMaterial({ vertexColors: THREE.VertexColors });
|
|
|
|
// const linePreview = new THREE.LineSegments(geometry, material);
|
|
|
|
//
|
|
|
|
// data.gcode.linePreview = linePreview;
|
|
|
|
// }
|
2017-11-12 11:53:45 +01:00
|
|
|
|
2017-07-20 10:29:33 +02:00
|
|
|
resolve(data.gcode);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 'PROGRESS': {
|
|
|
|
if (typeof onProgress !== 'undefined') {
|
|
|
|
onProgress(data);
|
2017-07-04 14:19:07 +02:00
|
|
|
}
|
2017-07-20 10:29:33 +02:00
|
|
|
break;
|
2017-05-13 14:48:48 +02:00
|
|
|
}
|
2017-07-20 10:29:33 +02:00
|
|
|
}
|
|
|
|
});
|
2017-05-13 14:48:48 +02:00
|
|
|
|
2018-02-12 00:10:44 +01:00
|
|
|
const { vertices, faces, objectIndexes, faceNormals } = geometry;
|
|
|
|
const buffers = [vertices.buffer, faces.buffer, objectIndexes.buffer, faceNormals.buffer];
|
|
|
|
|
2017-07-20 10:29:33 +02:00
|
|
|
slicerWorker.postMessage({
|
|
|
|
message: 'SLICE',
|
2017-12-19 12:38:58 +01:00
|
|
|
data: { settings, geometry, openObjectIndexes, constructLinePreview }
|
2018-02-12 00:10:44 +01:00
|
|
|
}, buffers);
|
2017-07-20 10:29:33 +02:00
|
|
|
});
|
2015-07-26 15:32:10 +02:00
|
|
|
}
|