awv3/dist/plugins/sketcher/handlers/trim.js

⚡ AWV3 embedded CAD

'use strict';

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

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

var _extends3 = _interopRequireDefault(_extends2);

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

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _map = require('babel-runtime/core-js/map');

var _map2 = _interopRequireDefault(_map);

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 _ccref = require('../ccref');

var _ccref2 = _interopRequireDefault(_ccref);

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

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

var _hover2 = _interopRequireDefault(_hover);

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

    function TrimHandler() {
        var _ref;

        (0, _classCallCheck3.default)(this, TrimHandler);

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

        var _this = (0, _possibleConstructorReturn3.default)(this, (_ref = TrimHandler.__proto__ || (0, _getPrototypeOf2.default)(TrimHandler)).call.apply(_ref, [this].concat(args)));

        _this.pool = _this.sketcher.pool;
        _this.trimObjects = new _map2.default();
        return _this;
    }

    (0, _createClass3.default)(TrimHandler, [{
        key: 'filterObjectsWithInteraction',
        value: function filterObjectsWithInteraction(object) {
            return object.id !== this.sketch.id && object.graphics !== undefined && !object.isConstraint();
        }
    }, {
        key: 'addInteraction',
        value: function addInteraction(object) {
            if (!this.filterObjectsWithInteraction(object)) return;
            var id = object.id;
            var trimObjects = [];
            var ats = [0, 1];
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = (0, _getIterator3.default)(this.sketch.children), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var otherObject = _step.value;

                    if (object.id !== otherObject.id) ats.push.apply(ats, (0, _toConsumableArray3.default)(intersections(object.geomParams, otherObject.geomParams)));
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            ats.sort();
            for (var i = 1; i < ats.length; ++i) {
                var graphics = trimGraphics(object, ats[i - 1], ats[i]);
                this.pool.add(graphics);
                var trimObject = {
                    id: id + '-trim-' + i,
                    graphics: graphics,
                    isPoint: function isPoint() {
                        return object.isPoint();
                    },
                    isConstraint: function isConstraint() {
                        return object.isConstraint();
                    }
                };
                trimObjects.push(trimObjects);
                (0, _get3.default)(TrimHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(TrimHandler.prototype), 'addInteraction', this).call(this, trimObject);
            }
            object.graphics.visible = false;
            this.trimObjects.set(id, trimObjects);
        }
    }, {
        key: 'removeInteraction',
        value: function removeInteraction(object) {
            var id = object.id;
            if (!this.trimObjects.has(id)) return;
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = (0, _getIterator3.default)(this.trimObjects.get(id)), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var trimObject = _step2.value;

                    (0, _get3.default)(TrimHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(TrimHandler.prototype), 'removeInteraction', this).call(this, trimObject);
                    this.pool.remove(trimObject.graphics);
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }

            if (object.graphics) object.graphics.visible = true;
            this.trimObjects.delete(id);
        }

        // override because base method calls removeInteraction based on interactions.keys instead of trimObjects.keys

    }, {
        key: 'removeInteractions',
        value: function removeInteractions() {
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = (0, _getIterator3.default)(this.trimObjects.keys()), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var id = _step3.value;

                    this.removeInteraction(new _ccref2.default(this.sketcher, id));
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }

            (0, _get3.default)(TrimHandler.prototype.__proto__ || (0, _getPrototypeOf2.default)(TrimHandler.prototype), 'removeInteractions', this).call(this);
        }
    }, {
        key: _object2.default.Events.Interaction.Clicked,
        value: function value(object, hitObject) {
            // TODO
            object.graphics.visible = false;
            object.graphics.removeInteraction();
        }
    }]);
    return TrimHandler;
}(_hover2.default);

exports.default = TrimHandler;


function trimGraphics(object, at0, at1) {
    var graphics = object.graphics;
    var geomParams = object.geomParams;
    var constructor = graphics.constructor;
    if (object.class === 'CC_Circle') constructor = (0, _getPrototypeOf2.default)(constructor); // Arc
    var result = new constructor();
    switch (object.class) {
        case 'CC_Circle':
            geomParams.start = 0;
            geomParams.end = 2 * Math.PI;
            geomParams.clockwise = false;
        // fallthrough
        case 'CC_Arc':
            var angleParams = (0, _geomutils.getArcAngles)(geomParams);
            var startA = THREE.Math.lerp(angleParams.start, angleParams.end, at0);
            var endA = THREE.Math.lerp(angleParams.start, angleParams.end, at1);
            result.updateCoordinateSystem(geomParams.coordinateSystem);
            result.updateWithAngles(geomParams.center, geomParams.radius, startA, endA, geomParams.scale);
            break;
        case 'CC_Line':
            var start = geomParams.start.clone();
            geomParams.start.lerp(geomParams.end, at0);
            geomParams.end.lerpVectors(start, geomParams.end, at1);
        // fallthrough
        default:
            result.updateFromGeomParams(geomParams);
            break;
    }
    return result;
}

function intersections(geomA, geomB) {
    switch ((0, _geomutils.getClass)(geomA)) {
        case 'CC_Line':
            switch ((0, _geomutils.getClass)(geomB)) {
                case 'CC_Point':
                    geomB = (0, _extends3.default)({}, geomB, { end: geomB.start.clone().addScalar(1) });
                // fallthrough
                case 'CC_Line':
                    var params = {};
                    var dirA = geomA.end.clone().sub(geomA.start),
                        dirB = geomB.end.clone().sub(geomB.start);
                    var lenA = dirA.length(),
                        lenB = dirB.length();
                    dirA.divideScalar(lenA), dirB.divideScalar(lenB);
                    var point = (0, _geomutils.intersectLines)(geomA.start, dirA, geomB.start, dirB, undefined, params);
                    if (!point || params.A <= 0 || params.A >= lenA || params.B < 0 || params.B > lenB) return [];
                    return [params.A / lenA];
                default:
                    return [];
            }
        default:
            return []; // TODO
    }
}