awv3
Version:
⚡ AWV3 embedded CAD
831 lines (693 loc) • 38.1 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _promise = require('babel-runtime/core-js/promise');
var _promise2 = _interopRequireDefault(_promise);
var _log = require('babel-runtime/core-js/math/log10');
var _log2 = _interopRequireDefault(_log);
var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');
var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
var _regenerator = require('babel-runtime/regenerator');
var _regenerator2 = _interopRequireDefault(_regenerator);
var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');
var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);
var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
var _entries = require('babel-runtime/core-js/object/entries');
var _entries2 = _interopRequireDefault(_entries);
var _getIterator2 = require('babel-runtime/core-js/get-iterator');
var _getIterator3 = _interopRequireDefault(_getIterator2);
var _values = require('babel-runtime/core-js/object/values');
var _values2 = _interopRequireDefault(_values);
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 _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
var _defineProperty3 = _interopRequireDefault(_defineProperty2);
var _extends3 = require('babel-runtime/helpers/extends');
var _extends4 = _interopRequireDefault(_extends3);
var _three = require('three');
var THREE = _interopRequireWildcard(_three);
var _orbit = require('../../controls/orbit');
var _orbit2 = _interopRequireDefault(_orbit);
var _elements = require('../../session/elements');
var _helpers = require('../../session/helpers');
var _materialselector = require('../../session/selection/materialselector');
var _plugin = require('../../session/plugin');
var _plugin2 = _interopRequireDefault(_plugin);
var _connections = require('../../session/store/connections');
var _object = require('../../three/object3');
var _object2 = _interopRequireDefault(_object);
var _dimension = require('../dimension/');
var _dimension2 = _interopRequireDefault(_dimension);
var _ccref = require('./ccref');
var _ccref2 = _interopRequireDefault(_ccref);
var _generator = require('./constraint/generator');
var _generator2 = _interopRequireDefault(_generator);
var _type = require('./constraint/type');
var ConstraintType = _interopRequireWildcard(_type);
var _commandrunner = require('./command/commandrunner');
var _commandrunner2 = _interopRequireDefault(_commandrunner);
var _highlevel = require('./command/highlevel');
var _lowlevel = require('./command/lowlevel');
var _multirunner = require('./command/multirunner');
var _multirunner2 = _interopRequireDefault(_multirunner);
var _graphics = require('./graphics');
var _graphics2 = _interopRequireDefault(_graphics);
var _handlers = require('./handlers');
var _handlers2 = _interopRequireDefault(_handlers);
var _viewutils = require('./viewutils');
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 resources = ["help", "arc-3points", "arc-midpoint", "arc-tagential", "cancel", "circle-3points", "circle-center-radius", "circle-ellipse", "coincident", "colinear", "concentric", "equal-distance", "equal-radius", "fillet-sketch", "fixation", "hdimension", "horizontality", "line", "measure", "midpoint", "parallelity", "perpendicularity", "point", "rectangle-2points", "rectangle-center-point", "symmetric", "tangency", "vdimension", "verticality"].reduce(function (prev, item) {
return (0, _extends4.default)({}, prev, (0, _defineProperty3.default)({}, item, require('./resources/' + item + '.png')));
}, {});
var Sketcher = function (_Plugin) {
(0, _inherits3.default)(Sketcher, _Plugin);
function Sketcher(session, args) {
(0, _classCallCheck3.default)(this, Sketcher);
var _this = (0, _possibleConstructorReturn3.default)(this, (Sketcher.__proto__ || (0, _getPrototypeOf2.default)(Sketcher)).call(this, session, (0, _extends4.default)({ type: "Sketch", icon: "rectangle-2points", resources: resources }, args)));
_this.activeSketch = new _ccref2.default(_this, _this.feature);
_this.autoconstraintIncremental = true;
_this.dimension = new _dimension2.default(_this.session, { name: "Dimensions", collapsed: false, closeable: false, parent: _this.id });
_this.dependencies.push(_this.dimension);
_this.graphics = new _map2.default();
_this.graphicScale = 0.1; //radius of a sketch point
_this.gridStep = 0.1; //size of grid cell
_this.multiRunner = new _multirunner2.default(_commandrunner2.default.bind(undefined, _this.connection));
_this.recalcIncremental = false;
_this.selector = new _materialselector.MaterialSelector(session);
_this.selector.hoveredProps = (0, _extends4.default)({}, _this.selector.hoveredProps, { polygonOffsetFactor: -10, polygonOffsetUnits: -50 });
_this.selector.selectedProps = (0, _extends4.default)({}, _this.selector.selectedProps, { polygonOffsetFactor: -5, polygonOffsetUnits: -25 });
_this.solveIncremental = false;
_this.transientGeomParams = new _map2.default();
_this.view = _this.session.pool.view;
_this.addElements();
return _this;
}
(0, _createClass3.default)(Sketcher, [{
key: 'addElements',
value: function addElements() {
var GF = _elements.Group.Format,
BF = _elements.Button.Format;
this.namedElements = {
selection: new _elements.Selection(this, { name: 'Selection', types: ['SketcherMesh'] }),
console: new _elements.Console(this),
dimension: new _elements.Link(this, { value: this.dimension.id }),
solveIncremental: new _elements.Checkbox(this, { name: 'Auto solve', value: this.solveIncremental }),
autoconstraintIncremental: new _elements.Checkbox(this, { name: 'Auto constraint', value: this.autoconstraintIncremental }),
recalcIncremental: new _elements.Checkbox(this, { name: 'Auto recalc', value: this.recalcIncremental }),
handlers: {
drag: new _elements.Button(this, { format: BF.Toggle, name: 'drag' }),
point: new _elements.Button(this, { format: BF.Toggle, name: 'point', icon: 'point' }),
line: new _elements.Button(this, { format: BF.Toggle, name: 'line', icon: 'line' }),
arccenter: new _elements.Button(this, { format: BF.Toggle, name: 'arc center', icon: 'arc-midpoint' }),
arccontrol: new _elements.Button(this, { format: BF.Toggle, name: 'arc control', icon: 'arc-3points' }),
arcmiddle: new _elements.Button(this, { format: BF.Toggle, name: 'arc middle', icon: 'arc-midpoint' }),
arctangent: new _elements.Button(this, { format: BF.Toggle, name: 'arc tangent', icon: 'arc-tagential' }),
polyline: new _elements.Button(this, { format: BF.Toggle, name: 'polyline', icon: 'line' }),
fillet: new _elements.Button(this, { format: BF.Toggle, name: 'fillet', icon: 'fillet-sketch' })
},
constraints: {
incidence: new _elements.Button(this, { name: 'incidence', icon: 'coincident' }),
tangency: new _elements.Button(this, { name: 'tangency', icon: 'tangency' }),
verticality: new _elements.Button(this, { name: 'verticality', icon: 'verticality' }),
horizontality: new _elements.Button(this, { name: 'horizontality', icon: 'horizontality' }),
parallelity: new _elements.Button(this, { name: 'parallelity', icon: 'parallelity' }),
perpendicularity: new _elements.Button(this, { name: 'perpendicularity', icon: 'perpendicularity' }),
fixation: new _elements.Button(this, { name: 'fixation', icon: 'fixation' }),
colinear: new _elements.Button(this, { name: 'colinear', icon: 'colinear' }),
concentric: new _elements.Button(this, { name: 'concentric', icon: 'concentric' }),
midpoint: new _elements.Button(this, { name: 'midpoint', icon: 'midpoint' }),
symmetric: new _elements.Button(this, { name: 'symmetric', icon: 'symmetric' }),
equalDistance: new _elements.Button(this, { name: 'equal distance', icon: 'equal-distance' }),
equalRadius: new _elements.Button(this, { name: 'equal radius', icon: 'equal-radius' }),
distance: new _elements.Button(this, { name: 'distance', icon: 'measure' }),
horizontalDistance: new _elements.Button(this, { name: 'horizontal distance', icon: 'hdimension' }),
verticalDistance: new _elements.Button(this, { name: 'vertical distance', icon: 'vdimension' }),
radius: new _elements.Button(this, { name: 'radius', icon: 'circle-center-radius' }),
angle: new _elements.Button(this, { name: 'angle', icon: 'help' }),
angleox: new _elements.Button(this, { name: 'angleox', icon: 'help' })
},
actions: {
solve: new _elements.Button(this, { name: 'Solve', icon: 'help' }),
autoconstr: new _elements.Button(this, { name: 'Autoconstr', icon: 'help' }),
delete: new _elements.Button(this, { name: 'Delete', icon: 'cancel' }),
duplicate: new _elements.Button(this, { name: 'Duplicate', icon: 'help' }),
dimensions: new _elements.Button(this, { name: 'Dimensions', icon: 'help' })
},
coordinateShower: {
xLabel: new _elements.Label(this, { value: 'cursor X: ' }),
xCoord: new _elements.Label(this, { value: NaN }),
yLabel: new _elements.Label(this, { value: 'cursor Y: ' }),
yCoord: new _elements.Label(this, { value: NaN })
}
};
var handlers = this.createToolbar((0, _values2.default)(this.namedElements.handlers).filter(function (x) {
return x.name !== 'drag';
}), function (x) {
return x;
}, 4);
handlers.format = GF.Collapse;
handlers.name = "Tools";
this.addElement(handlers);
var constraints = this.createToolbar((0, _values2.default)(this.namedElements.constraints), function (x) {
return x;
}, 5);
constraints.format = GF.Collapse;
constraints.name = "Constraints";
this.addElement(constraints);
this.addElement(new _elements.Group(this, { name: 'Actions', format: GF.Buttons, children: (0, _values2.default)(this.namedElements.actions) }));
this.addElement(this.namedElements.dimension);
this.addElement(new _elements.Group(this, { format: GF.Table, children: [this.namedElements.autoconstraintIncremental, this.namedElements.solveIncremental, this.namedElements.recalcIncremental] }));
this.addElement(this.namedElements.console);
this.addElement(new _elements.Group(this, { format: GF.Rows, children: [this.namedElements.coordinateShower.xLabel, this.namedElements.coordinateShower.xCoord, this.namedElements.coordinateShower.yLabel, this.namedElements.coordinateShower.yCoord] }));
this.setCursorCoordinates(undefined);
}
}, {
key: 'observeElements',
value: function observeElements() {
var _this2 = this;
var getSelected = function getSelected() {
return _this2.selector.getSelectedIds().map(function (id) {
return new _ccref2.default(_this2, id);
});
};
var value = function value(s) {
return s.value;
},
click = function click(s) {
return s.lastEvent;
};
this.apply.observe(click, function (event) {
_this2.store.dispatch(_connections.actions.recalc(_this2.connection.id));
});
this.namedElements.selection.observe(value, function (x) {
var entities = getSelected();
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = (0, _getIterator3.default)((0, _entries2.default)(_this2.namedElements.constraints)), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _step$value = (0, _slicedToArray3.default)(_step.value, 2),
name = _step$value[0],
element = _step$value[1];
element.active = ConstraintType[name].areEntitiesOk(entities);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
});
this.namedElements.console.observe(click, function () {
var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(x) {
return _regenerator2.default.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
if (!(x.key === 'Enter')) {
_context.next = 5;
break;
}
_context.next = 3;
return _this2.activeHandler.consoleExecute(x.target.value, false);
case 3:
_this2.namedElements.console.value = "";
_this2.refresh();
case 5:
case 'end':
return _context.stop();
}
}
}, _callee, _this2);
}));
return function (_x) {
return _ref.apply(this, arguments);
};
}());
this.namedElements.console.observe(value, function () {
var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(x) {
return _regenerator2.default.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
_this2.namedElements.console.children = _this2.activeHandler.consoleComplete(x);
_context2.next = 3;
return _this2.activeHandler.consoleExecute(x, true);
case 3:
_this2.refresh();
case 4:
case 'end':
return _context2.stop();
}
}
}, _callee2, _this2);
}));
return function (_x2) {
return _ref2.apply(this, arguments);
};
}());
this.namedElements.solveIncremental.observe(value, function (x) {
_this2.solveIncremental = x;
_this2.incrementalSolveConstraints();
});
this.namedElements.autoconstraintIncremental.observe(value, function (x) {
return _this2.autoconstraintIncremental = x;
});
this.namedElements.recalcIncremental.observe(value, function (x) {
_this2.recalcIncremental = x;
_this2.incrementalSolveConstraints();
});
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
var _loop = function _loop() {
var _step2$value = (0, _slicedToArray3.default)(_step2.value, 2),
handler = _step2$value[0],
element = _step2$value[1];
element.observe(value, function (x) {
return _this2.onHandlerToggle(handler, x);
});
};
for (var _iterator2 = (0, _getIterator3.default)((0, _entries2.default)(this.namedElements.handlers)), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
_loop();
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
var _loop2 = function _loop2() {
var _step3$value = (0, _slicedToArray3.default)(_step3.value, 2),
constraint = _step3$value[0],
element = _step3$value[1];
element.observe(click, function (x) {
var ct = ConstraintType[constraint];
var entities = getSelected();
if (!ct.areEntitiesOk(entities)) {
var _ref4;
// replace each line entity with its two endpoint
entities = (_ref4 = []).concat.apply(_ref4, (0, _toConsumableArray3.default)(entities.map(function (e) {
return e.isLine() ? e.children : e;
})));
if (!ct.areEntitiesOk(entities)) return;
}
_this2.selector.removeAll();
_this2.run((0, _highlevel.addCommand)(_this2.activeSketch, { class: ct.type, entities: entities, value: {} }));
_this2.incrementalSolveConstraints();
});
};
for (var _iterator3 = (0, _getIterator3.default)((0, _entries2.default)(this.namedElements.constraints)), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
_loop2();
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
this.namedElements.actions.solve.observe(click, function (x) {
return _this2.solveConstraints();
});
this.namedElements.actions.autoconstr.observe(click, function (x) {
return _this2.run(_this2.generateConstraints(_this2.activeSketch));
});
this.namedElements.actions.delete.observe(click, function (x) {
var selected = getSelected();
_this2.selector.removeAll();
_this2.run(_highlevel.removeCommand.apply(undefined, [_this2.activeSketch].concat((0, _toConsumableArray3.default)(selected))));
_this2.incrementalSolveConstraints();
});
this.namedElements.actions.duplicate.observe(click, function () {
var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(x) {
var objects;
return _regenerator2.default.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
objects = _this2.integration.selection.items.map(function (o) {
return o.object.parent;
});
_context3.next = 3;
return _this2.copyObjects(objects, new THREE.Vector3(15, 92, 0));
case 3:
_this2.integration.selection.deactivate();
case 4:
case 'end':
return _context3.stop();
}
}
}, _callee3, _this2);
}));
return function (_x3) {
return _ref3.apply(this, arguments);
};
}());
this.namedElements.actions.dimensions.observe(click, function (x) {
return _this2.createDimensions();
});
}
}, {
key: 'onEnabled',
value: function onEnabled() {
var _this3 = this;
this.pool.createInteraction().on((0, _defineProperty3.default)({}, _object2.default.Events.Lifecycle.Rendered, this.onRender.bind(this)));
this.connection.observe(function (state) {
return state.tree[_this3.activeSketch.id];
}, this.onSketchObjectChange.bind(this), {
fireOnStart: true,
unsubscribeOnUndefined: true,
onRemove: this.onSketchObjectRemove.bind(this),
manager: this.addSubscription.bind(this),
deep: true
});
this.observeElements();
this.namedElements.handlers['drag'].value = true;
this.dimension.enabled = true;
// Cam gets locked. Pool fades out. TODO: rotate is probably dependent on the sketch plane...
this.session.pool.updateMaterials();
var animation = this.session.pool.animate({ materials: { all: [{ opacity: 0.3 }] } });
this.oldProps = animation.getProperties();
animation.start(1000);
//this.session.pool.view.controls.noRotate = true;
this.view.controls.focus().zoom();
}
}, {
key: 'onDisabled',
value: function onDisabled() {
// Unlock controls, fade in pool
//this.session.pool.view.controls.noRotate = false;
this.view.controls.focus().zoom();
this.session.pool.animate(this.oldProps).start(500).wait();
this.dimension.enabled = false;
if (this.activeHandler) {
// disable possible complex handler (polyline) first, then disable drag
this.namedElements.handlers[this.activeHandler.name].value = false;
this.onHandlerToggleRecursion = true;
this.namedElements.handlers['drag'].value = false;
this.onHandlerToggleRecursion = false;
}
}
}, {
key: 'onSketchObjectChange',
value: function onSketchObjectChange(object) {
var id = object.id;
if (this.transientGeomParams.has(id)) this.transientGeomParams.delete(id); // actual new info overrides transient one
if (!this.graphics.has(id)) {
var g = (0, _graphics2.default)(object.class);
if (!g) return;
this.pool.add(g);
this.graphics.set(id, g);
}
new _ccref2.default(this, id).updateGraphics();
}
}, {
key: 'onSketchObjectRemove',
value: function onSketchObjectRemove(object) {
var id = object.id;
if (this.graphics.has(id)) {
this.graphics.get(id).destroy();
this.graphics.delete(id);
}
if (this.transientGeomParams.has(id)) this.transientGeomParams.delete(id);
}
}, {
key: 'simpleHandlerToggle',
value: function simpleHandlerToggle(handler, value) {
if (value) {
if (this.activeHandler) this.activeHandler.setEdgeHandler((0, _handlers2.default)(this, handler));else this.activeHandler = (0, _handlers2.default)(this, handler);
} else {
if (this.activeHandler.name === handler) this.activeHandler.destroy(), this.activeHandler = null;else this.activeHandler.setEdgeHandler(null);
}
}
}, {
key: 'onHandlerToggle',
value: function onHandlerToggle(handler, value) {
if (this.onHandlerToggleRecursion || !this.activeHandler) return this.simpleHandlerToggle(handler, value);
this.onHandlerToggleRecursion = true;
if (value) {
if (this.activeHandler.name === 'polyline') this.namedElements.handlers[this.activeHandler.edgeHandler.name].value = false;
if (this.activeHandler.name !== 'polyline' || !(handler === 'line' || handler.startsWith('arc'))) this.namedElements.handlers[this.activeHandler.name].value = false;
this.simpleHandlerToggle(handler, value);
if (handler === 'polyline') this.namedElements.handlers['line'].value = true;
} else {
if (handler === 'polyline') this.namedElements.handlers[this.activeHandler.edgeHandler.name].value = false;
this.simpleHandlerToggle(handler, value);
if (this.activeHandler) this.namedElements.handlers['line'].value = true;else this.namedElements.handlers['drag'].value = true;
}
this.onHandlerToggleRecursion = false;
}
}, {
key: 'onRender',
value: function onRender() {
var graphicDirty = this.updateGraphicScale();
if (graphicDirty) this.activeSketch.updateGraphicsRecursive();
}
}, {
key: 'updateGraphicScale',
value: function updateGraphicScale() {
// just take sketch origin as scaling point
var globalPnt = new THREE.Vector3(0, 0, 0).applyMatrix4(this.activeSketch.getMatrixWorld());;
// get length-to-pixels local scaling at this point
var coeff = (0, _viewutils.calcWorldToPixelScale)(this.view, globalPnt);
// set scale approximately
var approxScale = Math.max(7.0 / coeff, 1e-6);
// adjust to a good number
var newScale = Math.pow(10.0, Math.floor((0, _log2.default)(approxScale) * 5) / 5);
// set grid step
var newStep = Math.pow(10.0, Math.floor((0, _log2.default)(approxScale * 30) + 1e-3));
//change scale and grid atep
var changed = newStep !== this.gridStep || newScale !== this.graphicScale;
this.gridStep = newStep;
this.graphicScale = newScale;
return changed;
}
//only for showing them in GUI
}, {
key: 'setCursorCoordinates',
value: function setCursorCoordinates(pos) {
if (pos) {
this.namedElements.coordinateShower.xCoord.visible = true;
this.namedElements.coordinateShower.yCoord.visible = true;
this.namedElements.coordinateShower.xCoord.value = pos.x;
this.namedElements.coordinateShower.yCoord.value = pos.y;
} else {
this.namedElements.coordinateShower.xCoord.visible = false;
this.namedElements.coordinateShower.yCoord.visible = false;
}
}
}, {
key: 'refresh',
value: function refresh() {
this.view.invalidate();
}
}, {
key: 'run',
value: function run(command) {
return this.multiRunner.run({ command: 'Execute', task: (0, _lowlevel.Sequence)(command).unparse() });
}
}, {
key: 'checkSolveResult',
value: function checkSolveResult(result) {
// result: 0 - fail, 1 - well-defined, 2 - solved
if (result === 0) {
this.namedElements.solveIncremental.error = "Failed to solve sketch";
this.namedElements.solveIncremental.value = false;
return false;
}
this.namedElements.solveIncremental.error = undefined;
return true;
}
}, {
key: 'solveConstraints',
value: function () {
var _ref5 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4() {
var result;
return _regenerator2.default.wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
result = this.run((0, _lowlevel.Return)((0, _lowlevel.SolveConstraints)(this.activeSketch)));
this.run((0, _lowlevel.UpdateDimensions)(this.activeSketch));
_context4.t0 = this;
_context4.next = 5;
return result;
case 5:
_context4.t1 = _context4.sent;
return _context4.abrupt('return', _context4.t0.checkSolveResult.call(_context4.t0, _context4.t1));
case 7:
case 'end':
return _context4.stop();
}
}
}, _callee4, this);
}));
function solveConstraints() {
return _ref5.apply(this, arguments);
}
return solveConstraints;
}()
}, {
key: 'recalc',
value: function recalc() {
return this.run((0, _lowlevel.Recalc)());
}
}, {
key: 'incrementalSolveConstraints',
value: function () {
var _ref6 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee5() {
var solvePromise, recalcPromise, animation;
return _regenerator2.default.wrap(function _callee5$(_context5) {
while (1) {
switch (_context5.prev = _context5.next) {
case 0:
solvePromise = this.solveIncremental ? this.solveConstraints() : _promise2.default.resolve();
recalcPromise = this.recalcIncremental ? this.recalc() : _promise2.default.resolve();
_context5.next = 4;
return _promise2.default.all([solvePromise, recalcPromise]);
case 4:
//TODO: fix solid transparency bug
this.session.pool.updateMaterials();
animation = this.session.pool.animate({ materials: { all: [{ opacity: 0.3 }] } });
animation.start(1000);
case 7:
case 'end':
return _context5.stop();
}
}
}, _callee5, this);
}));
function incrementalSolveConstraints() {
return _ref6.apply(this, arguments);
}
return incrementalSolveConstraints;
}()
}, {
key: 'generateConstraints',
value: function generateConstraints(object) {
return new _generator2.default(this.activeSketch).generateImpliedConstraints(object);
}
}, {
key: 'autoconstraintCommands',
value: function autoconstraintCommands(object) {
return this.autoconstraintIncremental ? this.generateConstraints(object) : [];
}
}, {
key: 'moveUnderConstraints',
value: function () {
var _ref7 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee6(object, mouseDiff) {
var command, result;
return _regenerator2.default.wrap(function _callee6$(_context6) {
while (1) {
switch (_context6.prev = _context6.next) {
case 0:
if (!(mouseDiff.length() === 0.0)) {
_context6.next = 2;
break;
}
return _context6.abrupt('return');
case 2:
if (!this.solveInProgress) {
_context6.next = 4;
break;
}
return _context6.abrupt('return');
case 4:
this.solveInProgress = true; // hack: prevent multiple concurrent requests to the server
command = (0, _lowlevel.Return)((0, _lowlevel.MoveObjects)(this.activeSketch, object, mouseDiff));
_context6.prev = 6;
_context6.next = 9;
return this.run(command);
case 9:
result = _context6.sent;
this.checkSolveResult(result);
_context6.next = 15;
break;
case 13:
_context6.prev = 13;
_context6.t0 = _context6['catch'](6);
case 15:
this.solveInProgress = false;
case 16:
case 'end':
return _context6.stop();
}
}
}, _callee6, this, [[6, 13]]);
}));
function moveUnderConstraints(_x4, _x5) {
return _ref7.apply(this, arguments);
}
return moveUnderConstraints;
}()
}, {
key: 'copyObjects',
value: function copyObjects(objects, translate, rotate) {
return this.run((0, _lowlevel.CopyObjects)(this.activeSketch, objects, translate, rotate));
}
}, {
key: 'switchToOrthographicCamera',
value: function switchToOrthographicCamera(view, sketch) {
view.perspectiveControls = view.controls;
view.camera = new THREE.OrthographicCamera(0, 1, 1, 0);
sketch.localToWorld(view.camera.position.set(0, 0, 1000));
view.camera.up.transformDirection(sketch.matrixWorld);
view.camera.size = 1;
view.controls = view.controls.clone();
view.controls.noRotate = true;
view.controls.zoomMode = _orbit2.default.ZoomMode.Mouse;
view.controls.focus(sketch).zoom(200).now();
}
}, {
key: 'switchToPerspectiveCamera',
value: function switchToPerspectiveCamera(view) {
view.controls = view.perspectiveControls;
view.camera = view.controls.camera;
view.perspectiveControls = undefined;
}
}]);
return Sketcher;
}(_plugin2.default);
exports.default = Sketcher;