awv3/dist/plugins/sketcher/snapper.js

⚡ AWV3 embedded CAD

'use strict';

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

var _from = require('babel-runtime/core-js/array/from');

var _from2 = _interopRequireDefault(_from);

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

var _getIterator3 = _interopRequireDefault(_getIterator2);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var _three = require('three');

var THREE = _interopRequireWildcard(_three);

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 Snapper = function () {
    function Snapper(options) {
        (0, _classCallCheck3.default)(this, Snapper);

        this.sketch = options.sketch;
        this.gridStep = options.gridStep;
        this.pointRadius = options.pointRadius;
        this.ignoredIds = [];
        this.keyOffsets = undefined;

        this.maxSnapDistance = this.gridStep / 5.0;
        this.sketchPoints = undefined;
    }

    //note: subobjects (like endpoints of line) are also marked


    (0, _createClass3.default)(Snapper, [{
        key: 'ignoreObject',
        value: function ignoreObject(ccrefs) {
            ccrefs = [].concat(ccrefs);
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = (0, _getIterator3.default)(ccrefs), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var ccref = _step.value;
                    var _iteratorNormalCompletion2 = true;
                    var _didIteratorError2 = false;
                    var _iteratorError2 = undefined;

                    try {
                        for (var _iterator2 = (0, _getIterator3.default)(ccref.descendants), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                            var obj = _step2.value;

                            this.ignoredIds.push(obj.id);
                        }
                    } catch (err) {
                        _didIteratorError2 = true;
                        _iteratorError2 = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                _iterator2.return();
                            }
                        } finally {
                            if (_didIteratorError2) {
                                throw _iteratorError2;
                            }
                        }
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }

        //call this when dragging (or duplicating) many objects
        //  ccrefs: set of objects which is going to be moved
        //  mousePosition: where must cursor is currently
        //  dragged (optional): the object we drag with mouse (note: special case if it is point)

    }, {
        key: 'setDraggedObjects',
        value: function setDraggedObjects(ccrefs, mousePosition, dragged) {
            this.keyOffsets = [];
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = (0, _getIterator3.default)(ccrefs), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var obj = _step3.value;

                    var subpoints = (0, _from2.default)(obj.descendants).filter(function (obj) {
                        return obj.isPoint();
                    });
                    var _iteratorNormalCompletion4 = true;
                    var _didIteratorError4 = false;
                    var _iteratorError4 = undefined;

                    try {
                        for (var _iterator4 = (0, _getIterator3.default)(subpoints), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                            var pnt = _step4.value;

                            var offset = pnt.pos.clone().sub(mousePosition);
                            if (dragged && dragged.isPoint()) offset.set(0, 0, 0);
                            if (!this.keyOffsets.some(function (vec) {
                                return vec.distanceTo(offset) <= 1e-9;
                            })) this.keyOffsets.push(offset);
                        }
                    } catch (err) {
                        _didIteratorError4 = true;
                        _iteratorError4 = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion4 && _iterator4.return) {
                                _iterator4.return();
                            }
                        } finally {
                            if (_didIteratorError4) {
                                throw _iteratorError4;
                            }
                        }
                    }
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }
        }
        //use this to snap dragged object

    }, {
        key: 'snapDraggedObject',
        value: function snapDraggedObject(mousePosition) {
            var res = this.noneResult();
            var _iteratorNormalCompletion5 = true;
            var _didIteratorError5 = false;
            var _iteratorError5 = undefined;

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

                    var position = mousePosition.clone().add(key);
                    var tres = this.snapPoint(position);
                    tres.position.sub(key);
                    if (this.compareResult(res, tres) > 0) res = tres;
                }
            } catch (err) {
                _didIteratorError5 = true;
                _iteratorError5 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion5 && _iterator5.return) {
                        _iterator5.return();
                    }
                } finally {
                    if (_didIteratorError5) {
                        throw _iteratorError5;
                    }
                }
            }

            return res;
        }

        //use this method for drawing things (and NOT for dragging)

    }, {
        key: 'snapPoint',
        value: function snapPoint(position) {
            var res = this.noneResult();

            var resPoints = this.snapToSketchPoints(position);
            if (this.compareResult(res, resPoints) > 0) res = resPoints;

            var resGrid = this.snapToGrid(position);
            if (this.compareResult(res, resGrid) > 0) res = resGrid;

            res.position = res.displacement.clone().add(position);
            return res;
        }

        //internal methods

    }, {
        key: 'noneResult',
        value: function noneResult() {
            return {
                cost: Infinity,
                displacement: new THREE.Vector3(0, 0, 0)
            };
        }
    }, {
        key: 'compareResult',
        value: function compareResult(resA, resB) {
            if (Math.abs(resA.cost - resB.cost) <= 1e-3) return 0;
            return resA.cost < resB.cost ? -1 : 1;
        }
    }, {
        key: 'snapToGrid',
        value: function snapToGrid(position) {
            if (this.gridStep > 0) {
                var x = Math.round(position.x / this.gridStep) * this.gridStep;
                var y = Math.round(position.y / this.gridStep) * this.gridStep;
                var gridNode = new THREE.Vector3(x, y, 0);

                var dist = gridNode.distanceTo(position);
                if (dist < this.maxSnapDistance) {
                    return {
                        cost: dist,
                        displacement: gridNode.clone().sub(position)
                    };
                }
            }
            return this.noneResult();
        }
    }, {
        key: 'snapToSketchPoints',
        value: function snapToSketchPoints(position) {
            var res = this.noneResult();

            //note: cache sketch points for faster multi-snapping
            if (this.sketchPoints === undefined) this.sketchPoints = (0, _from2.default)(this.sketch.descendants).filter(function (obj) {
                return obj.isPoint();
            });

            var _iteratorNormalCompletion6 = true;
            var _didIteratorError6 = false;
            var _iteratorError6 = undefined;

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

                    if (this.ignoredIds.indexOf(obj.id) !== -1) continue;

                    var pointPos = obj.pos;
                    var dist = pointPos.distanceTo(position);
                    if (dist > this.maxSnapDistance) continue;

                    var snap = {
                        cost: dist,
                        displacement: pointPos.clone().sub(position),
                        toPoint: obj
                    };
                    if (this.compareResult(snap, res) < 0) res = snap;
                }
            } catch (err) {
                _didIteratorError6 = true;
                _iteratorError6 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
                        _iterator6.return();
                    }
                } finally {
                    if (_didIteratorError6) {
                        throw _iteratorError6;
                    }
                }
            }

            return res;
        }
    }]);
    return Snapper;
}();

exports.default = Snapper;