awv3/worker/helpers.js

⚡ AWV3 embedded CAD

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

exports.min = min;
exports.max = max;
exports.expand = expand;
exports.cross = cross;
exports.applyMatrix = applyMatrix;
exports.distance = distance;
exports.unpack = unpack;

var _pako = require('pako');

var _pako2 = _interopRequireDefault(_pako);

var _base64Arraybuffer = require('base64-arraybuffer');

var _base64Arraybuffer2 = _interopRequireDefault(_base64Arraybuffer);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function min(vec, v) {
    vec[0] = Math.min(vec[0], v[0]);
    vec[1] = Math.min(vec[1], v[1]);
    vec[2] = Math.min(vec[2], v[2]);
}

function max(vec, v) {
    vec[0] = Math.max(vec[0], v[0]);
    vec[1] = Math.max(vec[1], v[1]);
    vec[2] = Math.max(vec[2], v[2]);
}

function expand(vecMin, vecMax, v) {
    min(vecMin, v);
    max(vecMax, v);
}

function cross(vec, v) {
    var _vec = (0, _slicedToArray3.default)(vec, 3),
        x = _vec[0],
        y = _vec[1],
        z = _vec[2];

    vec[0] = y * v[2] - z * v[1];
    vec[1] = z * v[0] - x * v[2];
    vec[2] = x * v[1] - y * v[0];
}

function applyMatrix(vec, e) {
    var _vec2 = (0, _slicedToArray3.default)(vec, 3),
        x = _vec2[0],
        y = _vec2[1],
        z = _vec2[2];

    vec[0] = e[0] * x + e[4] * y + e[8] * z + e[12];
    vec[1] = e[1] * x + e[5] * y + e[9] * z + e[13];
    vec[2] = e[2] * x + e[6] * y + e[10] * z + e[14];
}

function distance(v1, v2) {
    var _v = (0, _slicedToArray3.default)(v1, 3),
        x1 = _v[0],
        y1 = _v[1],
        z1 = _v[2];

    var _v2 = (0, _slicedToArray3.default)(v2, 3),
        x2 = _v2[0],
        y2 = _v2[1],
        z2 = _v2[2];

    var dx = x1 - x2,
        dy = y1 - y2,
        dz = z1 - z2;
    return Math.sqrt(dx * dx + dy * dy + dz * dz);
}

function utf8ArrayToStr(array) {
    var out = void 0,
        i = void 0,
        len = void 0,
        c = void 0;
    var char2 = void 0,
        char3 = void 0;
    out = '';
    len = array.length;
    i = 0;
    while (i < len) {
        c = array[i++];
        switch (c >> 4) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                // 0xxxxxxx
                out += String.fromCharCode(c);
                break;
            case 12:
            case 13:
                // 110x xxxx   10xx xxxx
                char2 = array[i++];
                out += String.fromCharCode((c & 0x1f) << 6 | char2 & 0x3f);
                break;
            case 14:
                // 1110 xxxx  10xx xxxx  10xx xxxx
                char2 = array[i++];
                char3 = array[i++];
                out += String.fromCharCode((c & 0x0f) << 12 | (char2 & 0x3f) << 6 | (char3 & 0x3f) << 0);
                break;
        }
    }
    return out;
}

function decodeBuffer(buffer, length) {
    var data = '';
    if (typeof TextDecoder !== 'undefined') {
        var dataView = new DataView(buffer.buffer),
            decoder = new TextDecoder('utf-8');
        data = decoder.decode(dataView);
    } else data = utf8ArrayToStr(buffer);
    return data.slice(0, length);
}

function unpack(blob) {
    var stream = blob.data;
    if (!(stream instanceof Uint8Array)) stream = _base64Arraybuffer2.default.decode(blob.data);
    stream = _pako2.default.inflate(stream, { raw: true });
    stream = decodeBuffer(stream, blob.length || stream.length);
    blob.data = JSON.parse(stream);
    blob.size = stream.length;
}