awv3/plugins/sketcher/controls.js

⚡ AWV3 embedded CAD

'use strict';

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

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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

var _inherits3 = _interopRequireDefault(_inherits2);

var _geomutils = require('../sketcher/geomutils');

var _point = require('./graphics/point');

var _point2 = _interopRequireDefault(_point);

var _line = require('./graphics/line');

var _line2 = _interopRequireDefault(_line);

var _arc = require('./graphics/arc');

var _arc2 = _interopRequireDefault(_arc);

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

var _fillet2 = _interopRequireDefault(_fillet);

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

var _object2 = _interopRequireDefault(_object);

var _base = require('./handlers/base');

var _base2 = _interopRequireDefault(_base);

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

var filletHandler = exports.filletHandler = function (_BaseHandler) {
    (0, _inherits3.default)(filletHandler, _BaseHandler);

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

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

        _this.processor = new _fillet2.default(sketcher, sketcher.currentSketch);
        _this.busy = false;
        _this.filletablePoints = [];
        _this.filletArcs = [];
        _this.filletLines = [];

        _this.preview = null;

        _this.updateInteractiveObjects();
        return _this;
    }

    (0, _createClass3.default)(filletHandler, [{
        key: 'clear',
        value: function clear() {
            this.filletablePoints.forEach(function (obj) {
                return obj.interact.removeInteraction();
            });
            this.filletArcs.forEach(function (obj) {
                return obj.interact.removeInteraction();
            });
            this.filletLines.forEach(function (obj) {
                return obj.interact.removeInteraction();
            });
            this.filletablePoints = [];
            this.filletArcs = [];
            this.filletLines = [];
        }
    }, {
        key: 'updateInteractiveObjects',
        value: function updateInteractiveObjects() {
            var _this2 = this;

            this.clear();
            var allObjects = this.sketcher.currentSketch.getObjectsOnSketch();
            Sketch.ForObjectsWithChildren(allObjects, function (obj) {
                if (obj instanceof _point2.default) if (_this2.processor.RecognizeFilletableAngle(obj.position)) _this2.filletablePoints.push(obj);
            });
            allObjects.forEach(function (obj) {
                if (obj instanceof _arc2.default) if (_this2.processor.RecognizeFilletByArcOrEdge(obj)) _this2.filletArcs.push(obj);
                if (obj instanceof _line2.default) if (_this2.processor.RecognizeFilletByArcOrEdge(obj)) _this2.filletLines.push(obj);
            });

            var self = this;
            var sketcher = self.sketcher;

            function addPreview(info) {
                self.preview = {
                    obj: null,
                    lineStart: null,
                    lineEnd: null
                };

                if (info.obj instanceof _arc2.default) {
                    self.preview.objectIndex = createGeomObject({
                        start: info.obj.points[0].position.clone(),
                        end: info.obj.points[1].position.clone(),
                        center: info.obj.centerPoint.position.clone(),
                        clockwise: info.obj.clockwise
                    }, self.preview.obj);
                } else if (info.obj instanceof _line2.default) {
                    self.preview.objectIndex = createGeomObject({
                        start: info.obj.points[0].position.clone(),
                        end: info.obj.points[1].position.clone()
                    }, self.preview.obj);
                }

                self.preview.lineStart = createGeomObject({
                    start: info.lines[0].points[0].position.clone(),
                    end: info.lines[0].points[1].position.clone()
                }, self.preview.lineStart);

                self.preview.lineEnd = createGeomObject({
                    start: info.lines[1].points[0].position.clone(),
                    end: info.lines[1].points[1].position.clone()
                }, self.preview.lineEnd);

                self.sketcher.currentSketch.addAuxObject(self.preview.obj);
                self.sketcher.currentSketch.addAuxObject(self.preview.lineStart);
                self.sketcher.currentSketch.addAuxObject(self.preview.lineEnd);
            }
            function removePreview() {
                if (self.preview.obj) self.sketcher.currentSketch.removeAuxObject(self.preview.obj);
                if (self.preview.lineStart) self.sketcher.currentSketch.removeAuxObject(self.preview.lineStart);
                if (self.preview.lineEnd) self.sketcher.currentSketch.removeAuxObject(self.preview.lineEnd);
                self.preview = null;
            }
            function getPreviewGeomParams(info) {
                var newPnt = self.sketcher.interactionPoint.clone();

                var newGeomParams;
                if (info.obj instanceof _arc2.default) {
                    // Get arc constructed by two incident lines and mouse position
                    newGeomParams = (0, _geomutils.drawArcBy_Angle_M)(info.vertex.position.clone(), info.objEnds[0].position.clone().sub(info.vertex.position).normalize(), info.objEnds[1].position.clone().sub(info.vertex.position).normalize(), newPnt);
                    newGeomParams && (newGeomParams.clockwise = info.obj.clockwise);
                } else {
                    // Get line constructed by two incident lines and mouse position
                    newGeomParams = (0, _geomutils.drawLineBy_Angle_M)(info.vertex.position.clone(), info.objEnds[0].position.clone().sub(info.vertex.position).normalize(), info.objEnds[1].position.clone().sub(info.vertex.position).normalize(), newPnt);
                }

                var freeIdx0 = info.lineEnds[0] === info.lines[0].points[0] ? 1 : 0;
                var freeIdx1 = info.lineEnds[1] === info.lines[1].points[0] ? 1 : 0;

                if (newGeomParams) {
                    // Recalculate fillet to be sure its endpoints belong to the related linesegments
                    var filletOffset = newGeomParams.start.clone().sub(info.vertex.position).length();
                    var maxDist = Math.min(info.lines[0].points[freeIdx0].position.clone().sub(info.vertex.position).length(), info.lines[1].points[freeIdx1].position.clone().sub(info.vertex.position).length(), filletOffset);
                    if (filletOffset > maxDist) {
                        newGeomParams.start = newGeomParams.start.clone().sub(info.vertex.position).normalize().multiplyScalar(maxDist).add(info.vertex.position);
                        newGeomParams.end = newGeomParams.end.clone().sub(info.vertex.position).normalize().multiplyScalar(maxDist).add(info.vertex.position);

                        if (info.obj instanceof _arc2.default) {
                            var centerDir = newGeomParams.center.clone().sub(info.vertex.position).normalize();
                            var angle = newGeomParams.start.clone().sub(info.vertex.position).angleTo(newGeomParams.end.clone().sub(info.vertex.position));
                            newGeomParams.center = centerDir.multiplyScalar(maxDist / Math.cos(angle / 2)).add(info.vertex.position);
                        }
                    }
                } else {
                    // get two lines if fillet is singular
                    newGeomParams = {
                        start: info.vertex.position.clone(),
                        end: info.vertex.position.clone()
                    };
                }

                // redraw preview objects
                var oldPreview = self.preview.obj;
                var newPreview = createGeomObject(newGeomParams, self.preview.obj);
                if (newPreview != oldPreview) {
                    //new preview geometry was created: update sketch
                    if (oldPreview) self.sketch.removeAuxObject(oldPreview);
                    if (newPreview) {
                        self.sketch.addAuxObject(newPreview);
                        self.preview.obj = newPreview;
                    }
                }
                oldPreview = self.preview.lineStart;
                newPreview = createGeomObject({
                    start: info.lines[0].points[freeIdx0].position.clone(),
                    end: newGeomParams.start.clone()
                }, self.preview.lineStart);
                if (newPreview != oldPreview) {
                    //new preview geometry was created: update sketch
                    if (oldPreview) this.sketch.removeAuxObject(oldPreview);
                    if (newPreview) {
                        self.sketch.addAuxObject(newPreview);
                        self.preview.lineStart = newPreview;
                    }
                }

                oldPreview = self.preview.lineEnd;
                newPreview = createGeomObject({
                    start: info.lines[1].points[freeIdx1].position.clone(),
                    end: newGeomParams.end.clone()
                }, self.preview.lineEnd);
                if (newPreview != oldPreview) {
                    //new preview geometry was created: update sketch
                    if (oldPreview) self.sketch.removeAuxObject(oldPreview);
                    if (newPreview) {
                        self.sketch.addAuxObject(newPreview);
                        self.preview.lineEnd = newPreview;
                    }
                }
            }
            //interaction for creating new fillet when clicking at vertex
            function addFilletablePointInteraction(obj) {
                var _obj$interact$createI;

                obj.interact.createInteraction({
                    priority: 10 }).on((_obj$interact$createI = {}, (0, _defineProperty3.default)(_obj$interact$createI, _object2.default.Events.Interaction.Hovered, function (data) {
                    obj.interact.hover();
                    sketcher.refresh();
                }), (0, _defineProperty3.default)(_obj$interact$createI, _object2.default.Events.Interaction.Unhovered, function (data) {
                    obj.interact.unhover();
                    sketcher.refresh();
                }), (0, _defineProperty3.default)(_obj$interact$createI, _object2.default.Events.Interaction.Clicked, function (data) {
                    if (self.busy) return;
                    var info = self.processor.RecognizeFilletableAngle(obj.position);
                    if (!info) return;

                    var shiftPressed = self.sketcher.view.interaction.shiftKey;
                    if (shiftPressed) var params = self.processor.CalculateFilletParamsByRadius(info, 10.0);else var params = self.processor.CalculateChamferParamsByOffset(info, 10.0);
                    if (!params) return;

                    self.busy = true;
                    return self.processor.CreateNewFillet(info, params).then(function () {
                        self.updateInteractiveObjects();
                        // self.sketcher.refresh();
                        self.busy = false;
                    });
                }), _obj$interact$createI));
            }
            //interaction for deleting a present fillet when clicking in its arc
            function addFilletArcLineInteraction(obj) {
                var _obj$interact$createI2;

                obj.interact.createInteraction({
                    priority: 10 }).on((_obj$interact$createI2 = {}, (0, _defineProperty3.default)(_obj$interact$createI2, _object2.default.Events.Interaction.Hovered, function (data) {
                    obj.interact.hover();
                    sketcher.refresh();
                }), (0, _defineProperty3.default)(_obj$interact$createI2, _object2.default.Events.Interaction.Unhovered, function (data) {
                    obj.interact.unhover();
                    sketcher.refresh();
                }), (0, _defineProperty3.default)(_obj$interact$createI2, _object2.default.Events.Interaction.Picked, function (data) {
                    if (self.busy) return;
                    var info = self.processor.RecognizeFilletByArcOrEdge(obj);
                    if (!info) return;

                    var shiftPressed = self.sketcher.view.interaction.shiftKey;
                    if (!shiftPressed) {
                        var promise = self.processor.DeleteFillet(info);
                        return promise.then(function () {
                            info.obj.interact.unhover();
                            self.updateInteractiveObjects();
                            self.busy = false;
                        });
                    }

                    self.busy = true;
                    sketcher.view.controls.enabled = false; //do not update camera when dragging

                    info.obj.interact.unhover();
                    info.obj.setVisible(false);
                    info.lines.forEach(function (line) {
                        return line.setVisible(false);
                    });

                    addPreview(info);

                    sketcher.refresh();
                    self.busy = false;
                }), (0, _defineProperty3.default)(_obj$interact$createI2, _object2.default.Events.Interaction.Dropped, function (data) {
                    if (self.busy || !self.preview) return;

                    var info = self.processor.RecognizeFilletByArcOrEdge(obj);
                    if (!info) return;
                    self.busy = true;

                    if (info.obj instanceof _arc2.default) {
                        var radius = self.preview.obj ? self.preview.obj.radius : info.obj.radius;
                        var params = self.processor.CalculateFilletParamsByRadius(info, radius);
                    } else {
                        if (self.preview.obj) var offset = self.preview.obj.points[0].position.distanceTo(info.vertex.position);else var offset = info.obj.points[0].position.distanceTo(info.vertex);

                        var params = self.processor.CalculateChamferParamsByOffset(info, offset);
                    }

                    var promise;
                    if (!self.preview.obj || self.preview.obj.points[0].position.distanceTo(self.preview.obj.points[1].position) < 1e-3) {
                        promise = self.processor.DeleteFillet(info);
                    } else {
                        promise = self.processor.ChangeFillet(info, params);
                    }

                    removePreview();
                    sketcher.view.controls.enabled = true;

                    info.lines.forEach(function (line) {
                        return line.setVisible(true);
                    });
                    return promise.then(function () {
                        info.obj.setVisible(true);
                        info.obj.interact.unhover();
                        self.sketcher.refresh();
                        self.busy = false;
                        self.updateInteractiveObjects();
                    });
                }), (0, _defineProperty3.default)(_obj$interact$createI2, _object2.default.Events.Interaction.Dragged, function (data) {
                    if (self.busy || !self.preview) return;

                    var info = self.processor.RecognizeFilletByArcOrEdge(obj);
                    if (!info) return;

                    updatePreview(info);
                }), _obj$interact$createI2));
            }

            this.filletablePoints.forEach(addFilletablePointInteraction);
            this.filletArcs.forEach(addFilletArcLineInteraction);
            this.filletLines.forEach(addFilletArcLineInteraction);
        }
    }, {
        key: 'destroy',
        value: function destroy() {
            this.clear();
        }
    }]);
    return filletHandler;
}(_base2.default);

;