awv3/build/plugins/sketcher/handlers/fillet.js

⚡ AWV3 embedded CAD

'use strict';

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

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

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 _get3 = require('babel-runtime/helpers/get');

var _get4 = _interopRequireDefault(_get3);

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

var _inherits3 = _interopRequireDefault(_inherits2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

var _delay = require('delay');

var _delay2 = _interopRequireDefault(_delay);

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

var _object2 = _interopRequireDefault(_object);

var _hover = require('./hover');

var _hover2 = _interopRequireDefault(_hover);

var _fillet = require('../fillet');

var _fillet2 = _interopRequireDefault(_fillet);

var _preview = require('../preview');

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 FilletHandler = function (_HoverHandler) {
    (0, _inherits3.default)(FilletHandler, _HoverHandler);

    function FilletHandler(sketcher, name) {
        (0, _classCallCheck3.default)(this, FilletHandler);

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

        _this.processor = new _fillet2.default(sketcher.activeSketch);
        _this.preview = [new THREE.Object3D(), new THREE.Object3D()];
        _this.sketcher.pool.add(_this.preview[0]);
        _this.sketcher.pool.add(_this.preview[1]);
        return _this;
    }

    (0, _createClass3.default)(FilletHandler, [{
        key: 'destroy',
        value: function destroy() {
            var _get2;

            this.preview[0].destroy();
            this.preview[1].destroy();

            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
            }

            (_get2 = (0, _get4.default)(FilletHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(FilletHandler.prototype), 'destroy', this)).call.apply(_get2, [this].concat(args));
        }
    }, {
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            if (object.graphics === undefined) return false;
            if (object.isPoint() && !!this.processor.recognizeFilletableAngle(object.pos)) return true;
            if (object.isArc() && !!this.processor.recognizeFilletByArcOrEdge(object)) return true;
            return false;
        }
    }, {
        key: 'calculateNewFilletData',
        value: function calculateNewFilletData(object) {
            if (object.isPoint()) {
                var info = this.processor.recognizeFilletableAngle(object.pos);
                if (!info) return null;
                var offset = 1 / 4 * Math.min(info.lines[0].startPoint.pos.distanceTo(info.lines[0].endPoint.pos), info.lines[1].startPoint.pos.distanceTo(info.lines[1].endPoint.pos));
                var params = this.processor.calculateFilletParams(info, { offset: offset });
                if (!params) return null;
                return { info: info, params: params };
            }
        }
    }, {
        key: _object2.default.Events.Interaction.Hovered,
        value: function value(object, hitObject) {
            if (!hitObject.first) return;
            this.sketcher.selector.hover(hitObject);
            if (object.isPoint()) {
                var data = this.calculateNewFilletData(object);
                if (!data) return;
                (0, _preview.updateGeomObjectContainer)(this.preview[0], (0, _extends3.default)({
                    coordinateSystem: this.sketch.graphics.matrix,
                    scale: this.sketcher.graphicScale
                }, data.params));
            } else {
                var info = this.processor.recognizeFilletByArcOrEdge(object);
                for (var i = 0; i < 2; i++) {
                    (0, _preview.updateGeomObjectContainer)(this.preview[i], {
                        coordinateSystem: this.sketch.graphics.matrix,
                        scale: this.sketcher.graphicScale,
                        start: info.lineStarts[i].pos,
                        end: info.vertex.pos
                    });
                }
            }
        }
    }, {
        key: _object2.default.Events.Interaction.Unhovered,
        value: function value(object, hitObject) {
            this.sketcher.selector.unhover(hitObject);
            (0, _preview.updateGeomObjectContainer)(this.preview[0], {});
            (0, _preview.updateGeomObjectContainer)(this.preview[1], {});
        }
    }, {
        key: _object2.default.Events.Interaction.Clicked,
        value: function value(object, hitObject) {
            var _this2 = this;

            if (!hitObject.first) return;
            var commands = void 0;
            if (object.isPoint()) {
                var data = this.calculateNewFilletData(object);
                if (!data) return;
                commands = this.processor.createNewFilletStatement(data.info, data.params);
            } else {
                //object = arc
                var info = this.processor.recognizeFilletByArcOrEdge(object);
                commands = this.processor.deleteFilletStatement(info);
            }
            return (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                _context.next = 2;
                                return (0, _delay2.default)(1e-3);

                            case 2:
                                _context.next = 4;
                                return _this2.sketcher.run(commands);

                            case 4:
                                _context.next = 6;
                                return _this2.sketcher.incrementalSolveConstraints();

                            case 6:
                            case 'end':
                                return _context.stop();
                        }
                    }
                }, _callee, _this2);
            }))();
        }

        //TODO: perhaps remove?

    }, {
        key: _object2.default.Events.Interaction.Picked,
        value: function value(object, hitObject) {
            if (!hitObject.first) return;
            this.sketcher.view.controls.enabled = false; //do not update camera when dragging
        }
    }, {
        key: _object2.default.Events.Interaction.Dropped,
        value: function value(object, hitObject) {
            if (!hitObject.first) return;
            this.sketcher.view.controls.enabled = true;
        }
    }]);
    return FilletHandler;
}(_hover2.default);

exports.default = FilletHandler;