awv3/build/plugins/sketcher/constraint/visualizer.js

⚡ AWV3 embedded CAD

'use strict';

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

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 _set = require('babel-runtime/core-js/set');

var _set2 = _interopRequireDefault(_set);

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

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

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

var _createClass3 = _interopRequireDefault(_createClass2);

var _freeze = require('babel-runtime/core-js/object/freeze');

var _freeze2 = _interopRequireDefault(_freeze);

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 _constraint = require('../graphics/constraint');

var _constraint2 = _interopRequireDefault(_constraint);

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 Mode = (0, _freeze2.default)({
    Never: 0,
    Hover: 1,
    Always: 2
});

var Visualizer = function () {
    function Visualizer(sketcher, textures) {
        (0, _classCallCheck3.default)(this, Visualizer);

        this.mode = Mode.Hover;
        this.sketcher = sketcher;
        // Set of constraint ids to avoid iterating and filtering sketch.children
        this.constraints = new _set2.default();
        // Reverse mapping from entities to constraints
        this.entityFor = new _map2.default();
        // Used to track constraint positions in all modes
        this.visiblePositions = new _set2.default();
    }

    (0, _createClass3.default)(Visualizer, [{
        key: 'addConstraint',
        value: function addConstraint(constraint) {
            if (!(constraint.graphics instanceof _constraint2.default)) return;
            this.constraints.add(constraint.id);
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = (0, _getIterator3.default)(constraint.entities), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var entity = _step.value;

                    if (!this.entityFor.has(entity.id)) this.entityFor.set(entity.id, []);
                    this.entityFor.get(entity.id).push(constraint.id);
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }
    }, {
        key: 'removeConstraint',
        value: function removeConstraint(constraint) {
            var state = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : constraint.state;

            if (!(constraint.graphics instanceof _constraint2.default)) return;
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = (0, _getIterator3.default)(state.members.entities.members), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var _ref2 = _step2.value;
                    var id = _ref2.value;

                    var constraints = this.entityFor.get(id);
                    constraints.splice(constraints.indexOf(constraint.id), 1);
                    if (constraints.length === 0) this.entityFor.delete(id);
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }

            this.constraints.delete(constraint.id);
        }
    }, {
        key: 'updateConstraint',
        value: function updateConstraint(constraint) {
            this.place(constraint, constraint.entities[0], this.mode === Mode.Always);
        }
    }, {
        key: 'updateEntity',
        value: function updateEntity(entity) {
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = (0, _getIterator3.default)(this.entityFor.get(entity.id) || []), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var id = _step3.value;

                    var constraint = new _ccref2.default(this.sketcher, id);
                    if (!constraint.state) continue; // if entity is updated just before constraint is deleted (e.g. fillet point)
                    this.updateConstraint(constraint);
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }
        }
    }, {
        key: 'hover',
        value: function hover(entity, first) {
            if (this.mode !== Mode.Hover) return;
            if (entity.isConstraint()) return;
            if (first) this.unhoverAll();
            var _iteratorNormalCompletion4 = true;
            var _didIteratorError4 = false;
            var _iteratorError4 = undefined;

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

                    this.place(new _ccref2.default(this.sketcher, id), entity, true);
                }
            } catch (err) {
                _didIteratorError4 = true;
                _iteratorError4 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion4 && _iterator4.return) {
                        _iterator4.return();
                    }
                } finally {
                    if (_didIteratorError4) {
                        throw _iteratorError4;
                    }
                }
            }
        }
    }, {
        key: 'unhover',
        value: function unhover(entity, first) {
            if (this.mode !== Mode.Hover) return;
            if (entity.isConstraint()) return;
            // do nothing
        }
    }, {
        key: 'unhoverAll',
        value: function unhoverAll() {
            if (this.mode !== Mode.Hover) return;
            if (this.visiblePositions.size === 0) return;
            this.updateAll();
        }
    }, {
        key: 'place',
        value: function place(constraint, entity, visible) {
            var graphics = constraint.graphics,
                position = graphics.localMesh.position,
                gp = entity.geomParams;
            this.visiblePositions.delete(position);
            graphics.visible = visible;
            if (!visible) return;
            switch (entity.class) {
                case 'CC_Point':
                    position.copy(gp.start);
                    break;
                case 'CC_Line':
                    position.lerpVectors(gp.start, gp.end, 0.5);
                    break;
                case 'CC_Arc':
                    position.copy((0, _geomutils.getArcAngles)(gp).mid);
                    break;
                case 'CC_Circle':
                    position.copy(gp.center);
                    break;
                default:
                    position.set(0, 0, 0);
                    break;
            }
            var s = graphics.localMesh.scale.y;
            position.x -= s;
            position.y += s;
            triesLoop: for (var tries = 0; tries < 10; ++tries) {
                var _iteratorNormalCompletion5 = true;
                var _didIteratorError5 = false;
                var _iteratorError5 = undefined;

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

                        if (position.distanceToSquared(visiblePosition) < s * s) {
                            position.x += s * (1 + 1e-6);
                            continue triesLoop;
                        }
                    }
                } catch (err) {
                    _didIteratorError5 = true;
                    _iteratorError5 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion5 && _iterator5.return) {
                            _iterator5.return();
                        }
                    } finally {
                        if (_didIteratorError5) {
                            throw _iteratorError5;
                        }
                    }
                }

                break;
            }
            this.visiblePositions.add(position);
        }
    }, {
        key: 'updateAll',
        value: function updateAll() {
            var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.mode;

            this.mode = mode;
            this.visiblePositions.clear();
            var _iteratorNormalCompletion6 = true;
            var _didIteratorError6 = false;
            var _iteratorError6 = undefined;

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

                    this.updateConstraint(new _ccref2.default(this.sketcher, id));
                }
            } catch (err) {
                _didIteratorError6 = true;
                _iteratorError6 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
                        _iterator6.return();
                    }
                } finally {
                    if (_didIteratorError6) {
                        throw _iteratorError6;
                    }
                }
            }

            this.sketcher.refresh();
        }
    }]);
    return Visualizer;
}();

exports.default = Visualizer;