awv3/dist/plugins/dimension/graphics/base.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

var _isInteger = require('babel-runtime/core-js/number/is-integer');

var _isInteger2 = _interopRequireDefault(_isInteger);

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');

var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);

var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require('babel-runtime/helpers/createClass');

var _createClass3 = _interopRequireDefault(_createClass2);

var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');

var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);

var _get2 = require('babel-runtime/helpers/get');

var _get3 = _interopRequireDefault(_get2);

var _inherits2 = require('babel-runtime/helpers/inherits');

var _inherits3 = _interopRequireDefault(_inherits2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _object = require('../../../three/object3');

var _object2 = _interopRequireDefault(_object);

var _view = require('../../../core/view');

var _view2 = _interopRequireDefault(_view);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

var BaseGraphics = function (_THREE$Object3D) {
    (0, _inherits3.default)(BaseGraphics, _THREE$Object3D);

    function BaseGraphics(plugin) {
        var nLines = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        var nArcs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
        var nArrows = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
        (0, _classCallCheck3.default)(this, BaseGraphics);

        var _this = (0, _possibleConstructorReturn3.default)(this, (BaseGraphics.__proto__ || (0, _getPrototypeOf2.default)(BaseGraphics)).call(this));

        var colors = plugin.session.globals.colors;
        _this.lineGeometry = new THREE.CylinderBufferGeometry(1, 1, 1);
        _this.lineMaterial = new THREE.MeshBasicMaterial({ color: colors.primary });
        _this.arcSegmentGeometry = new THREE.CylinderBufferGeometry(1, 1, 1, 4, 1);
        _this.arcSegmentMaterial = new THREE.MeshBasicMaterial({ color: colors.primary });
        _this.arrowGeometry = new THREE.ConeBufferGeometry(1, 1);
        _this.arrowGeometry.translate(0, -0.5, 0);
        _this.arrowMaterial = new THREE.MeshBasicMaterial({ color: colors.primary });
        _this.arcSegments = 64;

        _this.plugin = plugin;
        _this.handles = plugin.handlePrototypes.map(function (handlePrototype) {
            return new handlePrototype(plugin);
        });
        _this.add.apply(_this, (0, _toConsumableArray3.default)(_this.handles));
        //this callback is async: otherwise CSS text and 3D geometry update at different times (causing visual lag)
        _this.createInteraction({ priority: 1000 }).on(_object2.default.Events.Lifecycle.Rendered, _this.onRender.bind(_this), { sync: false });
        if (nLines) {
            _this.lines = [];
            for (var i = 0; i < nLines; ++i) {
                _this.lines.push(new THREE.Mesh(_this.lineGeometry, _this.lineMaterial));
            }_this.add.apply(_this, (0, _toConsumableArray3.default)(_this.lines));
        }
        if (nArcs) {
            _this.arcs = [];
            for (var _i = 0; _i < nArcs; ++_i) {
                _this.arcs.push([]);
                for (var j = 0; j < _this.arcSegments; ++j) {
                    _this.arcs[_i].push(new THREE.Mesh(_this.arcSegmentGeometry, _this.arcSegmentMaterial));
                    _this.add.apply(_this, (0, _toConsumableArray3.default)(_this.arcs[_i]));
                }
            }
            _this.add.apply(_this, (0, _toConsumableArray3.default)(_this.arcs));
        }
        if (nArrows) {
            _this.arrows = [];
            for (var _i2 = 0; _i2 < nArrows; ++_i2) {
                _this.arrows.push(new THREE.Mesh(_this.arrowGeometry, _this.arrowMaterial));
            }_this.add.apply(_this, (0, _toConsumableArray3.default)(_this.arrows));
        }
        _this.dimPos2 = new THREE.Vector2();
        _this.text = '';
        _this.textNode = document.createElement('div');
        _this.textNode.setAttribute('style', 'position: absolute;\n            display: inline-block;\n            top: 0; left: 0; padding: 1px 2px;\n            color: ' + colors.text + ';\n            font-size: 9px;\n            pointer-events: none;');
        _this.userData.meta = {};
        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

        try {
            for (var _iterator = (0, _getIterator3.default)(_this.handles), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var hdl = _step.value;

                hdl.type = 'DimensionHandle';
            }
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally {
            try {
                if (!_iteratorNormalCompletion && _iterator.return) {
                    _iterator.return();
                }
            } finally {
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }

        _this.handles[0].material.meta = {};
        _this.destroyed = false;
        _this.viewFound().then(function (view) {
            if (_this.destroyed) return;
            view.dom.appendChild(_this.textNode);
        });
        return _this;
    }

    (0, _createClass3.default)(BaseGraphics, [{
        key: 'destroy',
        value: function destroy() {
            this.destroyed = true;
            if (this.textNode.parentElement) this.textNode.parentElement.removeChild(this.textNode);
            (0, _get3.default)(BaseGraphics.prototype.__proto__ || (0, _getPrototypeOf2.default)(BaseGraphics.prototype), 'destroy', this).call(this);
        }
    }, {
        key: 'onRender',
        value: function onRender() {
            var position = this.handles[0].getWorldPosition();
            var scale = this.view.calculateScaleFactor(position, 1.0);
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = (0, _getIterator3.default)(this.lines || []), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var line = _step2.value;

                    line.scale.x = line.scale.z = scale;
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }

            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = (0, _getIterator3.default)(this.arcs || []), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var arc = _step3.value;
                    var _iteratorNormalCompletion5 = true;
                    var _didIteratorError5 = false;
                    var _iteratorError5 = undefined;

                    try {
                        for (var _iterator5 = (0, _getIterator3.default)(arc), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                            var arcSegment = _step5.value;

                            arcSegment.scale.x = arcSegment.scale.z = scale;
                        }
                    } catch (err) {
                        _didIteratorError5 = true;
                        _iteratorError5 = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion5 && _iterator5.return) {
                                _iterator5.return();
                            }
                        } finally {
                            if (_didIteratorError5) {
                                throw _iteratorError5;
                            }
                        }
                    }
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }

            var _iteratorNormalCompletion4 = true;
            var _didIteratorError4 = false;
            var _iteratorError4 = undefined;

            try {
                for (var _iterator4 = (0, _getIterator3.default)(this.arrows || []), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                    var arrow = _step4.value;

                    arrow.scale.set(7 * scale, 15 * scale, 7 * scale);
                }
            } catch (err) {
                _didIteratorError4 = true;
                _iteratorError4 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion4 && _iterator4.return) {
                        _iterator4.return();
                    }
                } finally {
                    if (_didIteratorError4) {
                        throw _iteratorError4;
                    }
                }
            }

            var pos2 = this.view.getPoint2(position.clone());
            if (!this.dimPos2.equals(pos2)) {
                this.dimPos2.copy(pos2);
                this.textNode.style.transform = 'translate3d(' + (pos2.x + 15) + 'px, calc(-50% + ' + (pos2.y - 15) + 'px), 0)';
            }
            if (this.textNode.innerHTML !== this.handles[0].text) this.textNode.innerHTML = this.handles[0].text;
        }
    }, {
        key: 'updateLine',
        value: function updateLine(i, start, end) {
            var line = (0, _isInteger2.default)(i) ? this.lines[i] : i;
            // line.geometry describes a cylinder with axis from [0, -0.5, 0] to [0, 0.5, 0] and raidus 1
            line.position.lerpVectors(start, end, 0.5);
            line.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), end.clone().sub(start).normalize());
            line.scale.y = start.distanceTo(end);
        }
    }, {
        key: 'updateArc',
        value: function updateArc(i, center, radius, startAngle, endAngle) {
            var _this2 = this;

            var arc = this.arcs[i];
            for (var j = 0; j < this.arcSegments; ++j) {
                var arcSegment = arc[j];

                var _map = [j, j + 1].map(function (k) {
                    return THREE.Math.lerp(startAngle, endAngle, k / _this2.arcSegments);
                }),
                    _map2 = (0, _slicedToArray3.default)(_map, 2),
                    sStartAngle = _map2[0],
                    sEndAngle = _map2[1];

                var _map3 = [sStartAngle, sEndAngle].map(function (angle) {
                    return new THREE.Vector3(Math.cos(angle), Math.sin(angle), 0).multiplyScalar(radius).add(center);
                }),
                    _map4 = (0, _slicedToArray3.default)(_map3, 2),
                    start = _map4[0],
                    end = _map4[1];

                this.updateLine(arcSegment, start, end);
            }
        }
    }, {
        key: 'updateArrow',
        value: function updateArrow(i, end, dir) {
            var arrow = this.arrows[i];
            // arrow.geometry describes a cone with axis from [0, -1, 0] (r=1) to [0, 0, 0] (r=0)
            arrow.position.copy(end);
            arrow.quaternion.setFromUnitVectors(new THREE.Vector3(0, 1, 0), dir.clone().normalize());
        }
    }, {
        key: 'updateCoordinateSystem',
        value: function updateCoordinateSystem(csys) {
            csys = csys.map(function (row) {
                return new THREE.Vector3().fromArray(row);
            });
            this.matrix.makeBasis(csys[1], csys[2], csys[3]);
            this.matrix.setPosition(csys[0]);
            this.matrix.decompose(this.position, this.quaternion, this.scale);
            this.matrixWorldNeedsUpdate = true;
            this.updateMatrixWorld();
        }
    }, {
        key: 'updateFromState',
        value: function updateFromState(state) {
            this.lastState = state;
            this.userData.meta.id = state.id;
            this.updateCoordinateSystem(state.coordinateSystem);
            var _iteratorNormalCompletion6 = true;
            var _didIteratorError6 = false;
            var _iteratorError6 = undefined;

            try {
                for (var _iterator6 = (0, _getIterator3.default)(this.handles), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
                    var handle = _step6.value;

                    handle.updateFromState(state);
                }
            } catch (err) {
                _didIteratorError6 = true;
                _iteratorError6 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
                        _iterator6.return();
                    }
                } finally {
                    if (_didIteratorError6) {
                        throw _iteratorError6;
                    }
                }
            }

            this.handles[0].material.meta.id = state.id;
            this.handles[0].material.meta.box = this.handles[0].updateBounds().bounds.box;
            this.view.invalidate();
        }
    }]);
    return BaseGraphics;
}(THREE.Object3D);

exports.default = BaseGraphics;