awv3
Version:
⚡ AWV3 embedded CAD
400 lines (339 loc) • 18 kB
JavaScript
'use strict';
var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
var _extends2 = require('babel-runtime/helpers/extends');
var _extends3 = _interopRequireDefault(_extends2);
var _getIterator2 = require('babel-runtime/core-js/get-iterator');
var _getIterator3 = _interopRequireDefault(_getIterator2);
var _helpers = require('./helpers');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
self.addEventListener('message', function (message) {
message = message.data;
if (message.command === 'Blob' && message.type === 'Binary') {
delete message.type;
(0, _helpers.unpack)(message);
if (Array.isArray(message.data)) message.data = message.data[0];
}
optimizeGeometry(message, undefined);
self.postMessage({
action: 'Finished',
task: message.task
});
}, false);
function optimizeGeometry(blob) {
var data = blob.data,
task = blob.task,
options = blob.options;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = (0, _getIterator3.default)(data.containers), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var container = _step.value;
var transfer = [];
var id = container.id,
owner = container.owner,
properties = container.properties;
var meshes = container.meshes || [];
var lines = container.lines || [];
var arcs = container.arcs || [];
var edges = container.edges || [];
var group = void 0,
points = void 0,
x = void 0,
y = void 0,
z = void 0;
//lines = [];
//edges = [];
//arcs = [];
if (lines.length > 0 || arcs.length > 0 || edges.length > 0) {
(function () {
var line = void 0,
count = 0,
segments = 64;
var result = container.line = {
groups: []
};
var mergedLines = lines.reduce(function (prev, next) {
return prev + next.points.length;
}, 0);
var mergedEdges = edges.reduce(function (prev, next) {
return prev + next.points.length;
}, 0);
var mergedArcs = arcs.reduce(function (prev, next) {
return prev + segments * 6;
}, 0);
result.vertices = new Float32Array(mergedLines + mergedEdges + mergedArcs);
transfer.push(result.vertices.buffer);
var lastVec = void 0;
mergedLines = 0;
for (var index = 0, length = lines.length; index < length; index++) {
line = lines[index];
points = line.points;
if (options.materials.multi) {
if (!line.properties) line.properties = {};
group = {
start: mergedLines,
count: points.length,
index: result.groups.length,
color: line.properties.color || properties.color,
opacity: line.opacity,
meta: (0, _extends3.default)({
id: line.id,
container: id,
owner: owner,
layer: line.properties.layer || properties.layer
}, line.meta, {
type: 'line',
start: [points[0], points[1], points[2]],
end: [points[points.length - 3], points[points.length - 2], points[points.length - 1]],
min: [+Infinity, +Infinity, +Infinity],
max: [-Infinity, -Infinity, -Infinity]
})
};
result.groups.push(group);
}
for (var i = 0, l = points.length / 3; i < l; i++) {
mergedLines += 3;
lastVec = [points[i * 3 + 0], points[i * 3 + 1], points[i * 3 + 2]];
result.vertices[count++] = lastVec[0];
result.vertices[count++] = lastVec[1];
result.vertices[count++] = lastVec[2];
options.materials.multi && (0, _helpers.expand)(group.meta.min, group.meta.max, lastVec);
}
}
for (var _index = 0, _length = edges.length; _index < _length; _index++) {
line = edges[_index];
points = line.points;
if (options.materials.multi) {
if (!line.properties) line.properties = {};
group = {
start: mergedLines,
count: points.length,
index: result.groups.length,
color: line.properties.color || properties.color,
opacity: line.opacity,
meta: (0, _extends3.default)({
id: line.id,
container: id,
owner: owner,
layer: line.properties.layer || properties.layer
}, line.meta, {
type: 'line',
start: [points[0], points[1], points[2]],
end: [points[points.length - 3], points[points.length - 2], points[points.length - 1]],
min: [+Infinity, +Infinity, +Infinity],
max: [-Infinity, -Infinity, -Infinity]
})
};
result.groups.push(group);
}
lastVec = [points[0], points[1], points[2]];
options.materials.multi && (0, _helpers.expand)(group.meta.min, group.meta.max, lastVec);
for (var _i = 1, _l = points.length / 3; _i < _l; _i++) {
mergedLines += 3;
result.vertices[count++] = lastVec[0];
result.vertices[count++] = lastVec[1];
result.vertices[count++] = lastVec[2];
lastVec = [points[_i * 3 + 0], points[_i * 3 + 1], points[_i * 3 + 2]];
result.vertices[count++] = lastVec[0];
result.vertices[count++] = lastVec[1];
result.vertices[count++] = lastVec[2];
options.materials.multi && (0, _helpers.expand)(group.meta.min, group.meta.max, lastVec);
}
}
var radius = void 0,
thetaStart = void 0,
thetaLength = void 0,
center = void 0,
zAxis = void 0,
xAxis = void 0,
yAxis = void 0,
scalar = void 0,
invScalar = void 0,
segment = void 0,
start = void 0;
for (var _index2 = 0, _length2 = arcs.length; _index2 < _length2; _index2++) {
line = arcs[_index2];
radius = line.radius;
thetaStart = 0;
thetaLength = Math.abs(Math.abs(line.angle) - Math.PI) < 0.000001 ? Math.PI * 2 : line.angle;
center = line.center;
zAxis = line.zAxis;
xAxis = line.xAxis;
yAxis = line.zAxis;
var _yAxis = yAxis;
var _yAxis2 = (0, _slicedToArray3.default)(_yAxis, 3);
x = _yAxis2[0];
y = _yAxis2[1];
z = _yAxis2[2];
yAxis[0] = y * xAxis[2] - z * xAxis[1];
yAxis[1] = z * xAxis[0] - x * xAxis[2];
yAxis[2] = x * xAxis[1] - y * xAxis[0];
scalar = Math.sqrt(yAxis[0] * yAxis[0] + yAxis[1] * yAxis[1] + yAxis[2] * yAxis[2]);
if (scalar !== 0) {
invScalar = 1 / scalar;
yAxis[0] *= invScalar;
yAxis[1] *= invScalar;
yAxis[2] *= invScalar;
} else {
yAxis[0] = yAxis[1] = yAxis[2] = 0;
}
var matrix = [xAxis[0], xAxis[1], xAxis[2], 0, yAxis[0], yAxis[1], yAxis[2], 0, zAxis[0], zAxis[1], zAxis[2], 0, center[0], center[1], center[2], 1];
segment = thetaStart / segments * thetaLength;
lastVec = [radius * Math.cos(segment), radius * Math.sin(segment), 0];
(0, _helpers.applyMatrix)(lastVec, matrix);
if (options.materials.multi) {
if (!line.properties) line.properties = {};
group = {
start: mergedLines,
count: segments * 6,
index: result.groups.length,
color: line.properties.color || properties.color,
opacity: line.opacity,
meta: (0, _extends3.default)({}, line.meta, {
id: line.id,
container: id,
owner: owner,
layer: line.properties.layer || properties.layer,
type: 'arc',
circle: line.isCircle,
angle: line.angle,
start: lastVec,
radius: radius,
thetaStart: thetaStart,
thetaLength: thetaLength,
center: center,
zAxis: zAxis,
xAxis: xAxis,
yAxis: yAxis,
min: [+Infinity, +Infinity, +Infinity],
max: [-Infinity, -Infinity, -Infinity]
})
};
result.groups.push(group);
(0, _helpers.expand)(group.meta.min, group.meta.max, lastVec);
}
for (var _i2 = 1; _i2 <= segments; _i2++) {
mergedLines += 6;
result.vertices[count++] = lastVec[0];
result.vertices[count++] = lastVec[1];
result.vertices[count++] = lastVec[2];
segment = thetaStart + _i2 / segments * thetaLength;
lastVec = [radius * Math.cos(segment), radius * Math.sin(segment), 0];
(0, _helpers.applyMatrix)(lastVec, matrix);
result.vertices[count++] = lastVec[0];
result.vertices[count++] = lastVec[1];
result.vertices[count++] = lastVec[2];
options.materials.multi && (0, _helpers.expand)(group.meta.min, group.meta.max, lastVec);
}
}
delete container.lines;
})();
}
if (meshes.length > 0) {
var mesh = void 0,
mergedVertices = 0,
mergedIndices = 0,
mergedUvs = 0,
mergedNormals = 0;
var result = container.mesh = {
groups: []
};
for (var index = 0, l = meshes.length; index < l; index++) {
mesh = meshes[index];
mergedVertices += mesh.vertices.length;
mergedIndices += mesh.indices.length;
if (!!mesh.uvs) mergedUvs += mesh.uvs.length;
if (!!mesh.normals) mergedNormals += mesh.normals.length;
}
// Merge meshes that aren't individual
if (mergedVertices > 0) {
result.vertices = new Float32Array(mergedVertices);
transfer.push(result.vertices.buffer);
result.indices = new Uint32Array(mergedIndices);
transfer.push(result.indices.buffer);
if (mergedUvs > 0) {
result.uvs = new Float32Array(mergedUvs);
transfer.push(result.uvs.buffer);
}
if (mergedNormals > 0) {
result.normals = new Float32Array(mergedNormals);
transfer.push(result.normals.buffer);
}
mergedVertices = 0;mergedIndices = 0;mergedUvs = 0;mergedNormals = 0;
var offset = 0,
indexCount = 0;
for (var i = 0; i < meshes.length; i++) {
mesh = meshes[i];
if (options.materials.multi) {
if (!mesh.properties) mesh.properties = {};
if (!mesh.properties.surface) mesh.properties.surface = {};
group = {
start: indexCount,
count: mesh.indices.length,
index: result.groups.length,
color: mesh.properties.color || properties.color,
opacity: mesh.opacity,
meta: (0, _extends3.default)({}, mesh.meta, {
id: mesh.id,
container: id,
owner: owner,
layer: mesh.properties.layer || properties.layer,
type: mesh.properties.surface.type
}, mesh.properties.surface, {
min: [+Infinity, +Infinity, +Infinity],
max: [-Infinity, -Infinity, -Infinity]
})
};
result.groups.push(group);
indexCount += mesh.indices.length;
}
for (var vindex = 0, vlen = mesh.vertices.length / 3; vindex < vlen; vindex++) {
x = mesh.vertices[vindex * 3 + 0];
y = mesh.vertices[vindex * 3 + 1];
z = mesh.vertices[vindex * 3 + 2];
options.materials.multi && (0, _helpers.expand)(group.meta.min, group.meta.max, [x, y, z]);
result.vertices[mergedVertices++] = x;
result.vertices[mergedVertices++] = y;
result.vertices[mergedVertices++] = z;
}
for (var findex = 0, flen = mesh.indices.length; findex < flen; findex++) {
result.indices[mergedIndices++] = mesh.indices[findex] + offset;
}
if (!!mesh.uvs) {
for (var uvindex = 0, uvlen = mesh.uvs.length; uvindex < uvlen; uvindex++) {
result.uvs[mergedUvs++] = mesh.uvs[uvindex];
}
}
if (!!mesh.normals) {
for (var nindex = 0, nlen = mesh.normals.length; nindex < nlen; nindex++) {
result.normals[mergedNormals++] = mesh.normals[nindex];
}
}
offset += mesh.vertices.length / 3;
}
}
delete container.meshes;
}
self.postMessage({
action: 'Result',
result: container,
task: task
}, transfer);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}